8165296: update existing i18n test cases of test/java/util
Reviewed-by: okutsu
Contributed-by: nancy.nigam@oracle.com
--- a/jdk/test/java/text/testlib/IntlTest.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/text/testlib/IntlTest.java Thu Nov 17 11:40:50 2016 +0530
@@ -89,6 +89,9 @@
case "-nothrow":
nothrow = true;
break;
+ case "-exitcode":
+ exitCode = true;
+ break;
default:
Method m = testMethods.get(arg);
if (m == null) {
@@ -138,7 +141,12 @@
}
}
if (nothrow) {
- System.exit(errorCount);
+ if (exitCode) {
+ System.exit(errorCount);
+ }
+ if (errorCount > 0) {
+ throw new IllegalArgumentException("encountered " + errorCount + " errors");
+ }
}
}
@@ -243,7 +251,7 @@
*/
void usage() {
System.out.println(getClass().getName() +
- ": [-verbose] [-nothrow] [-prompt] [test names]");
+ ": [-verbose] [-nothrow] [-exitcode] [-prompt] [test names]");
System.out.println(" Available test names:");
for (String methodName : testMethods.keySet()) {
@@ -254,7 +262,7 @@
private boolean prompt;
private boolean nothrow;
protected boolean verbose;
-
+ private boolean exitCode;
private PrintWriter log;
private int indentLevel;
private boolean needLineFeed;
--- a/jdk/test/java/util/Calendar/Bug4766302.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/Bug4766302.java Thu Nov 17 11:40:50 2016 +0530
@@ -29,9 +29,11 @@
import java.util.GregorianCalendar;
+@SuppressWarnings("serial")
public class Bug4766302 {
static class MyCalendar extends GregorianCalendar {
+
boolean isTimeStillSet() {
return isTimeSet;
}
--- a/jdk/test/java/util/Calendar/Bug4958050.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/Bug4958050.java Thu Nov 17 11:40:50 2016 +0530
@@ -29,9 +29,11 @@
import java.util.Locale;
import java.util.TimeZone;
+
import static java.util.Calendar.*;
public class Bug4958050 {
+
static int errorCount = 0;
public static void main(String[] args) {
@@ -41,87 +43,87 @@
System.out.println("Time zone = " + cal.getTimeZone().getID());
// Test the week fields
- int[] weekFields = { WEEK_OF_YEAR, WEEK_OF_MONTH, DAY_OF_WEEK_IN_MONTH };
+ int[] weekFields = {WEEK_OF_YEAR, WEEK_OF_MONTH, DAY_OF_WEEK_IN_MONTH};
for (int i = 0; i < weekFields.length; i++) {
int field = weekFields[i];
// add()
cal.clear();
- cal.set(1919, DECEMBER, 14-7, 23, 50, 00);
+ cal.set(1919, DECEMBER, 14 - 7, 23, 50, 00);
cal.add(weekFields[i], +1);
if (!cal.checkDate(1919, DECEMBER, 14)) {
- error("1919/12/07: add("+cal.getFieldName(weekFields[i])+", +1)\n"
- + cal.getMessage()+" " + cal.toDateTimeString());
+ error("1919/12/07: add(" + Koyomi.getFieldName(weekFields[i]) + ", +1)\n"
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
- cal.set(1930, JUNE, 21-7);
+ cal.set(1930, JUNE, 21 - 7);
cal.add(weekFields[i], +1);
if (!cal.checkDateTime(1930, JUNE, 21, 01, 00, 00, 000)) {
- error("1930/6/14: add("+cal.getFieldName(weekFields[i])+", +1)\n"
- + cal.getMessage()+" " + cal.toDateTimeString());
+ error("1930/6/14: add(" + Koyomi.getFieldName(weekFields[i]) + ", +1)\n"
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
// roll()
cal.clear();
- cal.set(1919, DECEMBER, 14-7, 23, 50, 00);
+ cal.set(1919, DECEMBER, 14 - 7, 23, 50, 00);
cal.roll(weekFields[i], +1);
if (!cal.checkDate(1919, DECEMBER, 14)) {
- error("1919/12/07: roll("+cal.getFieldName(weekFields[i])+", +1)\n"
- + cal.getMessage()+" " + cal.toDateTimeString());
+ error("1919/12/07: roll(" + Koyomi.getFieldName(weekFields[i]) + ", +1)\n"
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
- cal.set(1930, JUNE, 21-7);
+ cal.set(1930, JUNE, 21 - 7);
cal.roll(weekFields[i], +1);
if (!cal.checkDateTime(1930, JUNE, 21, 01, 00, 00, 000)) {
- error("1930/6/14: roll("+cal.getFieldName(weekFields[i])+", +1)\n"
- + cal.getMessage()+" " + cal.toDateTimeString());
+ error("1930/6/14: roll(" + Koyomi.getFieldName(weekFields[i]) + ", +1)\n"
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
}
// Test the day fields
- int[] dayFields = { DAY_OF_MONTH, DAY_OF_YEAR, DAY_OF_WEEK };
+ int[] dayFields = {DAY_OF_MONTH, DAY_OF_YEAR, DAY_OF_WEEK};
for (int i = 0; i < dayFields.length; i++) {
int field = dayFields[i];
// add()
cal.clear();
- cal.set(1919, DECEMBER, 14-1, 23, 50, 00);
+ cal.set(1919, DECEMBER, 14 - 1, 23, 50, 00);
cal.add(field, +1);
if (!cal.checkDate(1919, DECEMBER, 14)) {
- error("1919/12/13: add("+cal.getFieldName(field)+", +1)\n"
- + cal.getMessage()+" " + cal.toDateTimeString());
+ error("1919/12/13: add(" + Koyomi.getFieldName(field) + ", +1)\n"
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
cal.set(1919, DECEMBER, 14, 00, 00, 00);
cal.add(field, -1);
if (!cal.checkDate(1919, DECEMBER, 13)) {
- error("1919/12/14: add("+cal.getFieldName(field)+", -1)\n"
- + cal.getMessage()+" " + cal.toDateTimeString());
+ error("1919/12/14: add(" + Koyomi.getFieldName(field) + ", -1)\n"
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
- cal.set(1930, JUNE, 21-1);
+ cal.set(1930, JUNE, 21 - 1);
cal.add(field, +1);
if (!cal.checkDateTime(1930, JUNE, 21, 01, 00, 00, 000)) {
- error("1930/6/20: add("+cal.getFieldName(field)+", +1)\n"
- + cal.getMessage() + cal.toDateTimeString());
+ error("1930/6/20: add(" + Koyomi.getFieldName(field) + ", +1)\n"
+ + cal.getMessage() + cal.toDateTimeString());
}
cal.clear();
cal.set(1930, JUNE, 21, 01, 00, 00);
cal.add(field, -1);
if (!cal.checkDateTime(1930, JUNE, 20, 01, 00, 00, 000)) {
- error("1930/6/21: add("+cal.getFieldName(field)+", -1)\n"
- + cal.getMessage()+" " + cal.toDateTimeString());
+ error("1930/6/21: add(" + Koyomi.getFieldName(field) + ", -1)\n"
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
// roll()
cal.clear();
- cal.set(1930, JUNE, 21-1);
+ cal.set(1930, JUNE, 21 - 1);
int amount = +1;
if (field == DAY_OF_WEEK) {
amount += 700;
}
cal.roll(field, amount);
if (!cal.checkDateTime(1930, JUNE, 21, 01, 00, 00, 000)) {
- error("1930/6/20: roll("+cal.getFieldName(field)+", +"+amount+")\n"
- + cal.getMessage() + " " + cal.toDateTimeString());
+ error("1930/6/20: roll(" + Koyomi.getFieldName(field) + ", +" + amount + ")\n"
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
cal.set(1930, JUNE, 21, 01, 00, 00);
@@ -131,93 +133,93 @@
}
cal.roll(field, amount);
if (!cal.checkDateTime(1930, JUNE, 20, 01, 00, 00, 000)) {
- error("1930/6/21: roll("+cal.getFieldName(field)+", "+amount+")\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ error("1930/6/21: roll(" + Koyomi.getFieldName(field) + ", " + amount + ")\n"
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
}
// Test the AM_PM field
// add()
cal.clear();
- cal.set(1919, DECEMBER, 14-1, 23, 50, 00);
+ cal.set(1919, DECEMBER, 14 - 1, 23, 50, 00);
cal.add(AM_PM, +1);
if (!cal.checkDate(1919, DECEMBER, 14)
- || !cal.checkFieldValue(AM_PM, AM)) {
+ || !cal.checkFieldValue(AM_PM, AM)) {
error("1919/12/13: add(AM_PM, +1)\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
- cal.set(1930, JUNE, 21-1, 12, 00, 00);
+ cal.set(1930, JUNE, 21 - 1, 12, 00, 00);
cal.add(AM_PM, +1);
if (!cal.checkDate(1930, JUNE, 21)
- || !cal.checkFieldValue(AM_PM, AM)) {
+ || !cal.checkFieldValue(AM_PM, AM)) {
error("1930/6/20: add(AM_PM, +1)\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
- cal.set(1930, JUNE, 21-2, 12, 00, 00);
+ cal.set(1930, JUNE, 21 - 2, 12, 00, 00);
cal.add(AM_PM, +3);
if (!cal.checkDate(1930, JUNE, 21)
- || !cal.checkFieldValue(AM_PM, AM)) {
+ || !cal.checkFieldValue(AM_PM, AM)) {
error("1930/6/10: add(AM_PM, +3)\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
cal.set(1919, DECEMBER, 14, 11, 50, 00);
cal.add(AM_PM, -1);
- if (!cal.checkDateTime(1919, DECEMBER, 14-1, 23, 50, 00, 000)
- || !cal.checkFieldValue(AM_PM, PM)) {
+ if (!cal.checkDateTime(1919, DECEMBER, 14 - 1, 23, 50, 00, 000)
+ || !cal.checkFieldValue(AM_PM, PM)) {
error("1919/12/14 11:50:00: add(AM_PM, -1)\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
cal.set(1930, JUNE, 21, 01, 00, 00);
cal.add(AM_PM, -1);
- if (!cal.checkDateTime(1930, JUNE, 21-1, 01+12, 00, 00, 000)
- || !cal.checkFieldValue(AM_PM, PM)) {
+ if (!cal.checkDateTime(1930, JUNE, 21 - 1, 01 + 12, 00, 00, 000)
+ || !cal.checkFieldValue(AM_PM, PM)) {
error("1930/6/20: add(AM_PM, -1)\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
cal.set(1930, JUNE, 21, 01, 00, 00);
cal.add(AM_PM, -3);
- if (!cal.checkDateTime(1930, JUNE, 21-2, 01+12, 00, 00, 000)
- || !cal.checkFieldValue(AM_PM, PM)) {
+ if (!cal.checkDateTime(1930, JUNE, 21 - 2, 01 + 12, 00, 00, 000)
+ || !cal.checkFieldValue(AM_PM, PM)) {
error("1930/6/10: add(AM_PM, -3)\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
// roll() (should NOT change the date)
cal.clear();
- cal.set(1919, DECEMBER, 14-1, 23, 50, 00);
+ cal.set(1919, DECEMBER, 14 - 1, 23, 50, 00);
cal.roll(AM_PM, +1);
- if (!cal.checkDateTime(1919, DECEMBER, 14-1, 23-12, 50, 00, 000)
- || !cal.checkFieldValue(AM_PM, AM)) {
+ if (!cal.checkDateTime(1919, DECEMBER, 14 - 1, 23 - 12, 50, 00, 000)
+ || !cal.checkFieldValue(AM_PM, AM)) {
error("1919/12/13: roll(AM_PM, +1)\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
- cal.set(1930, JUNE, 21-1, 12, 00, 00);
+ cal.set(1930, JUNE, 21 - 1, 12, 00, 00);
cal.roll(AM_PM, +1);
- if (!cal.checkDateTime(1930, JUNE, 21-1, 12-12, 00, 00, 000)
- || !cal.checkFieldValue(AM_PM, AM)) {
+ if (!cal.checkDateTime(1930, JUNE, 21 - 1, 12 - 12, 00, 00, 000)
+ || !cal.checkFieldValue(AM_PM, AM)) {
error("1930/6/20: roll(AM_PM, +1)\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
cal.clear();
- cal.set(1930, JUNE, 21-2, 12, 00, 00);
+ cal.set(1930, JUNE, 21 - 2, 12, 00, 00);
cal.roll(AM_PM, +3);
- if (!cal.checkDateTime(1930, JUNE, 21-2, 12-12, 00, 00, 000)
- || !cal.checkFieldValue(AM_PM, AM)) {
+ if (!cal.checkDateTime(1930, JUNE, 21 - 2, 12 - 12, 00, 00, 000)
+ || !cal.checkFieldValue(AM_PM, AM)) {
error("1930/6/10: roll(AM_PM, +3)\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
// Test the HOUR_OF_DAY field
@@ -227,7 +229,7 @@
cal.add(HOUR_OF_DAY, +1);
if (!cal.checkDateTime(1930, JUNE, 21, 01, 00, 00, 000)) {
error("1930/6/20 23:00:00: add(HOUR_OF_DAY, +1)\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
// roll() (should NOT change the date)
@@ -236,7 +238,7 @@
cal.roll(HOUR_OF_DAY, +1);
if (!cal.checkDateTime(1930, JUNE, 20, 00, 00, 00, 000)) {
error("1930/6/20 23:00:00: roll(HOUR_OF_DAY, +1)\n"
- + cal.getMessage()+" "+cal.toDateTimeString());
+ + cal.getMessage() + " " + cal.toDateTimeString());
}
checkErrors();
--- a/jdk/test/java/util/Calendar/CalendarRegression.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/CalendarRegression.java Thu Nov 17 11:40:50 2016 +0530
@@ -34,11 +34,24 @@
* @library /java/text/testlib
* @run main CalendarRegression
*/
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.text.DateFormat;
+import java.text.NumberFormat;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.SimpleTimeZone;
+import java.util.TimeZone;
-import java.lang.reflect.*;
-import java.io.*;
-import java.util.*;
-import java.text.*;
+import static java.util.Calendar.*;
public class CalendarRegression extends IntlTest {
@@ -47,99 +60,101 @@
}
/*
- Synopsis: java.sql.Timestamp constructor works wrong on Windows 95
+ Synopsis: java.sql.Timestamp constructor works wrong on Windows 95
- ==== Here is the test ====
- public static void main (String args[]) {
- java.sql.Timestamp t= new java.sql.Timestamp(0,15,5,5,8,13,123456700);
- logln("expected=1901-04-05 05:08:13.1234567");
- logln(" result="+t);
- }
+ ==== Here is the test ====
+ public static void main (String args[]) {
+ java.sql.Timestamp t= new java.sql.Timestamp(0,15,5,5,8,13,123456700);
+ logln("expected=1901-04-05 05:08:13.1234567");
+ logln(" result="+t);
+ }
- ==== Here is the output of the test on Solaris or NT ====
- expected=1901-04-05 05:08:13.1234567
- result=1901-04-05 05:08:13.1234567
+ ==== Here is the output of the test on Solaris or NT ====
+ expected=1901-04-05 05:08:13.1234567
+ result=1901-04-05 05:08:13.1234567
- ==== Here is the output of the test on Windows95 ====
- expected=1901-04-05 05:08:13.1234567
- result=1901-04-05 06:08:13.1234567
- */
-
+ ==== Here is the output of the test on Windows95 ====
+ expected=1901-04-05 05:08:13.1234567
+ result=1901-04-05 06:08:13.1234567
+ */
public void Test4031502() {
// This bug actually occurs on Windows NT as well, and doesn't
// require the host zone to be set; it can be set in Java.
String[] ids = TimeZone.getAvailableIDs();
boolean bad = false;
- for (int i=0; i<ids.length; ++i) {
+ for (int i = 0; i < ids.length; ++i) {
TimeZone zone = TimeZone.getTimeZone(ids[i]);
GregorianCalendar cal = new GregorianCalendar(zone);
cal.clear();
cal.set(1900, 15, 5, 5, 8, 13);
- if (cal.get(Calendar.HOUR) != 5) {
- logln(zone.getID() + " " +
- //zone.useDaylightTime() + " " +
- cal.get(Calendar.DST_OFFSET) / (60*60*1000) + " " +
- zone.getRawOffset() / (60*60*1000) +
- ": HOUR = " + cal.get(Calendar.HOUR));
+ if (cal.get(HOUR) != 5) {
+ logln(zone.getID() + " "
+ + //zone.useDaylightTime() + " "
+ + cal.get(DST_OFFSET) / (60 * 60 * 1000) + " "
+ + zone.getRawOffset() / (60 * 60 * 1000)
+ + ": HOUR = " + cal.get(HOUR));
bad = true;
}
}
- if (bad) errln("TimeZone problems with GC");
+ if (bad) {
+ errln("TimeZone problems with GC");
+ }
}
public void Test4035301() {
GregorianCalendar c = new GregorianCalendar(98, 8, 7);
GregorianCalendar d = new GregorianCalendar(98, 8, 7);
- if (c.after(d) ||
- c.after(c) ||
- c.before(d) ||
- c.before(c) ||
- !c.equals(c) ||
- !c.equals(d))
+ if (c.after(d)
+ || c.after(c)
+ || c.before(d)
+ || c.before(c)
+ || !c.equals(c)
+ || !c.equals(d)) {
errln("Fail");
+ }
}
public void Test4040996() {
String[] ids = TimeZone.getAvailableIDs(-8 * 60 * 60 * 1000);
SimpleTimeZone pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, ids[0]);
- pdt.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
- pdt.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
+ pdt.setStartRule(APRIL, 1, SUNDAY, 2 * 60 * 60 * 1000);
+ pdt.setEndRule(OCTOBER, -1, SUNDAY, 2 * 60 * 60 * 1000);
Calendar calendar = new GregorianCalendar(pdt);
- calendar.set(Calendar.MONTH,3);
- calendar.set(Calendar.DAY_OF_MONTH,18);
- calendar.set(Calendar.SECOND, 30);
+ calendar.set(MONTH, 3);
+ calendar.set(DAY_OF_MONTH, 18);
+ calendar.set(SECOND, 30);
- logln("MONTH: " + calendar.get(Calendar.MONTH));
- logln("DAY_OF_MONTH: " +
- calendar.get(Calendar.DAY_OF_MONTH));
- logln("MINUTE: " + calendar.get(Calendar.MINUTE));
- logln("SECOND: " + calendar.get(Calendar.SECOND));
+ logln("MONTH: " + calendar.get(MONTH));
+ logln("DAY_OF_MONTH: "
+ + calendar.get(DAY_OF_MONTH));
+ logln("MINUTE: " + calendar.get(MINUTE));
+ logln("SECOND: " + calendar.get(SECOND));
- calendar.add(Calendar.SECOND,6);
+ calendar.add(SECOND, 6);
//This will print out todays date for MONTH and DAY_OF_MONTH
//instead of the date it was set to.
//This happens when adding MILLISECOND or MINUTE also
- logln("MONTH: " + calendar.get(Calendar.MONTH));
- logln("DAY_OF_MONTH: " +
- calendar.get(Calendar.DAY_OF_MONTH));
- logln("MINUTE: " + calendar.get(Calendar.MINUTE));
- logln("SECOND: " + calendar.get(Calendar.SECOND));
- if (calendar.get(Calendar.MONTH) != 3 ||
- calendar.get(Calendar.DAY_OF_MONTH) != 18 ||
- calendar.get(Calendar.SECOND) != 36)
+ logln("MONTH: " + calendar.get(MONTH));
+ logln("DAY_OF_MONTH: "
+ + calendar.get(DAY_OF_MONTH));
+ logln("MINUTE: " + calendar.get(MINUTE));
+ logln("SECOND: " + calendar.get(SECOND));
+ if (calendar.get(MONTH) != 3
+ || calendar.get(DAY_OF_MONTH) != 18
+ || calendar.get(SECOND) != 36) {
errln("Fail: Calendar.add misbehaves");
+ }
}
public void Test4051765() {
Calendar cal = Calendar.getInstance();
cal.setLenient(false);
- cal.set(Calendar.DAY_OF_WEEK, 0);
+ cal.set(DAY_OF_WEEK, 0);
try {
cal.getTime();
errln("Fail: DAY_OF_WEEK 0 should be disallowed");
- }
- catch (IllegalArgumentException e) {
+ } catch (IllegalArgumentException e) {
return;
}
}
@@ -200,51 +215,54 @@
logln("DST_OFFSET: "
+ (calendar.get(calendar.DST_OFFSET)/(60*60*1000))); // in hours
}
- */
-
+ */
public void Test4059654() {
GregorianCalendar gc = new GregorianCalendar();
gc.set(1997, 3, 1, 15, 16, 17); // April 1, 1997
- gc.set(Calendar.HOUR, 0);
- gc.set(Calendar.AM_PM, Calendar.AM);
- gc.set(Calendar.MINUTE, 0);
- gc.set(Calendar.SECOND, 0);
- gc.set(Calendar.MILLISECOND, 0);
+ gc.set(HOUR, 0);
+ gc.set(AM_PM, AM);
+ gc.set(MINUTE, 0);
+ gc.set(SECOND, 0);
+ gc.set(MILLISECOND, 0);
Date cd = gc.getTime();
+ @SuppressWarnings("deprecation")
Date exp = new Date(97, 3, 1, 0, 0, 0);
- if (!cd.equals(exp))
+ if (!cd.equals(exp)) {
errln("Fail: Calendar.set broken. Got " + cd + " Want " + exp);
+ }
}
public void Test4061476() {
SimpleDateFormat fmt = new SimpleDateFormat("ddMMMyy", Locale.UK);
Calendar cal = GregorianCalendar.getInstance(TimeZone.getTimeZone("GMT"),
- Locale.UK);
+ Locale.UK);
fmt.setCalendar(cal);
- try
- {
- Date date = fmt.parse("29MAY97");
- cal.setTime(date);
- }
- catch (Exception e) {;}
- cal.set(Calendar.HOUR_OF_DAY, 13);
- logln("Hour: "+cal.get(Calendar.HOUR_OF_DAY));
- cal.add(Calendar.HOUR_OF_DAY, 6);
- logln("Hour: "+cal.get(Calendar.HOUR_OF_DAY));
- if (cal.get(Calendar.HOUR_OF_DAY) != 19)
- errln("Fail: Want 19 Got " + cal.get(Calendar.HOUR_OF_DAY));
+ try {
+ Date date = fmt.parse("29MAY97");
+ cal.setTime(date);
+ } catch (Exception e) {
+ }
+ cal.set(HOUR_OF_DAY, 13);
+ logln("Hour: " + cal.get(HOUR_OF_DAY));
+ cal.add(HOUR_OF_DAY, 6);
+ logln("Hour: " + cal.get(HOUR_OF_DAY));
+ if (cal.get(HOUR_OF_DAY) != 19) {
+ errln("Fail: Want 19 Got " + cal.get(HOUR_OF_DAY));
+ }
}
public void Test4070502() {
+ @SuppressWarnings("deprecation")
Date d = getAssociatedDate(new Date(98, 0, 30));
Calendar cal = new GregorianCalendar();
cal.setTime(d);
- if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY ||
- cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY)
+ if (cal.get(DAY_OF_WEEK) == SATURDAY
+ || cal.get(DAY_OF_WEEK) == SUNDAY) {
errln("Fail: Want weekday Got " + d);
+ }
}
/**
@@ -260,13 +278,13 @@
//cal.add(field, amount); //<-- PROBLEM SEEN WITH field = DATE,MONTH
// cal.getTime(); // <--- REMOVE THIS TO SEE BUG
while (true) {
- int wd = cal.get(Calendar.DAY_OF_WEEK);
- if (wd == Calendar.SATURDAY || wd == Calendar.SUNDAY) {
- cal.add(Calendar.DATE, 1);
+ int wd = cal.get(DAY_OF_WEEK);
+ if (wd == SATURDAY || wd == SUNDAY) {
+ cal.add(DATE, 1);
// cal.getTime();
+ } else {
+ break;
}
- else
- break;
}
return cal.getTime();
}
@@ -278,41 +296,47 @@
void dowTest(boolean lenient) {
GregorianCalendar cal = new GregorianCalendar();
- cal.set(1997, Calendar.AUGUST, 12); // Wednesday
+ cal.set(1997, AUGUST, 12); // Wednesday
// cal.getTime(); // Force update
cal.setLenient(lenient);
- cal.set(1996, Calendar.DECEMBER, 1); // Set the date to be December 1, 1996
- int dow = cal.get(Calendar.DAY_OF_WEEK);
- int min = cal.getMinimum(Calendar.DAY_OF_WEEK);
- int max = cal.getMaximum(Calendar.DAY_OF_WEEK);
+ cal.set(1996, DECEMBER, 1); // Set the date to be December 1, 1996
+ int dow = cal.get(DAY_OF_WEEK);
+ int min = cal.getMinimum(DAY_OF_WEEK);
+ int max = cal.getMaximum(DAY_OF_WEEK);
logln(cal.getTime().toString());
- if (min != Calendar.SUNDAY || max != Calendar.SATURDAY)
+ if (min != SUNDAY || max != SATURDAY) {
errln("FAIL: Min/max bad");
- if (dow < min || dow > max)
+ }
+ if (dow < min || dow > max) {
errln("FAIL: Day of week " + dow + " out of range");
- if (dow != Calendar.SUNDAY)
+ }
+ if (dow != SUNDAY) {
errln("FAIL: Day of week should be SUNDAY Got " + dow);
+ }
}
+ @SuppressWarnings("deprecation")
public void Test4071385() {
Calendar cal = Calendar.getInstance();
- cal.setTime(new Date(98, Calendar.JUNE, 24));
- cal.set(Calendar.MONTH, Calendar.NOVEMBER); // change a field
+ cal.setTime(new Date(98, JUNE, 24));
+ cal.set(MONTH, NOVEMBER); // change a field
logln(cal.getTime().toString());
- if (!cal.getTime().equals(new Date(98, Calendar.NOVEMBER, 24)))
+ if (!cal.getTime().equals(new Date(98, NOVEMBER, 24))) {
errln("Fail");
+ }
}
public void Test4073929() {
GregorianCalendar foo1 = new GregorianCalendar(1997, 8, 27);
- foo1.add(Calendar.DAY_OF_MONTH, +1);
- int testyear = foo1.get(Calendar.YEAR);
- int testmonth = foo1.get(Calendar.MONTH);
- int testday = foo1.get(Calendar.DAY_OF_MONTH);
- if (testyear != 1997 ||
- testmonth != 8 ||
- testday != 28)
+ foo1.add(DAY_OF_MONTH, +1);
+ int testyear = foo1.get(YEAR);
+ int testmonth = foo1.get(MONTH);
+ int testday = foo1.get(DAY_OF_MONTH);
+ if (testyear != 1997
+ || testmonth != 8
+ || testday != 28) {
errln("Fail: Calendar not initialized");
+ }
}
public void Test4083167() {
@@ -322,27 +346,26 @@
Date firstDate = new Date();
Calendar cal = new GregorianCalendar();
cal.setTime(firstDate);
- long firstMillisInDay = cal.get(Calendar.HOUR_OF_DAY) * 3600000L +
- cal.get(Calendar.MINUTE) * 60000L +
- cal.get(Calendar.SECOND) * 1000L +
- cal.get(Calendar.MILLISECOND);
+ long firstMillisInDay = cal.get(HOUR_OF_DAY) * 3600000L
+ + cal.get(MINUTE) * 60000L
+ + cal.get(SECOND) * 1000L
+ + cal.get(MILLISECOND);
logln("Current time: " + firstDate.toString());
- for (int validity=0; validity<30; validity++) {
- Date lastDate = new Date(firstDate.getTime() +
- (long)validity*1000*24*60*60);
+ for (int validity = 0; validity < 30; validity++) {
+ Date lastDate = new Date(firstDate.getTime()
+ + (long) validity * 1000 * 24 * 60 * 60);
cal.setTime(lastDate);
- long millisInDay = cal.get(Calendar.HOUR_OF_DAY) * 3600000L +
- cal.get(Calendar.MINUTE) * 60000L +
- cal.get(Calendar.SECOND) * 1000L +
- cal.get(Calendar.MILLISECOND);
+ long millisInDay = cal.get(HOUR_OF_DAY) * 3600000L
+ + cal.get(MINUTE) * 60000L
+ + cal.get(SECOND) * 1000L
+ + cal.get(MILLISECOND);
if (firstMillisInDay != millisInDay) {
errln("Day has shifted " + lastDate);
}
}
- }
- finally {
+ } finally {
TimeZone.setDefault(saveZone);
}
}
@@ -359,61 +382,60 @@
TimeZone.setDefault(TimeZone.getTimeZone("Europe/London"));
date = new SimpleDateFormat("zzzz");
- Calendar cal=Calendar.getInstance();
- cal.set(1997,Calendar.SEPTEMBER,30);
- Date now=cal.getTime();
+ Calendar cal = Calendar.getInstance();
+ cal.set(1997, SEPTEMBER, 30);
+ Date now = cal.getTime();
String formattedDate = date.format(now);
if (!formattedDate.equals(summerTime)) {
errln("Wrong display name \"" + formattedDate
- + "\" for <" + now + ">");
+ + "\" for <" + now + ">");
}
- int weekOfYear = cal.get(Calendar.WEEK_OF_YEAR);
+ int weekOfYear = cal.get(WEEK_OF_YEAR);
if (weekOfYear != 40) {
errln("Wrong week-of-year " + weekOfYear
- + " for <" + now + ">");
+ + " for <" + now + ">");
}
- cal.set(1996,Calendar.DECEMBER,31);
- now=cal.getTime();
+ cal.set(1996, DECEMBER, 31);
+ now = cal.getTime();
formattedDate = date.format(now);
if (!formattedDate.equals(standardTime)) {
errln("Wrong display name \"" + formattedDate
- + "\" for <" + now + ">");
+ + "\" for <" + now + ">");
}
- weekOfYear = cal.get(Calendar.WEEK_OF_YEAR);
+ weekOfYear = cal.get(WEEK_OF_YEAR);
if (weekOfYear != 1) {
errln("Wrong week-of-year " + weekOfYear
- + " for <" + now + ">");
+ + " for <" + now + ">");
}
- cal.set(1997,Calendar.JANUARY,1);
- now=cal.getTime();
+ cal.set(1997, JANUARY, 1);
+ now = cal.getTime();
formattedDate = date.format(now);
if (!formattedDate.equals(standardTime)) {
errln("Wrong display name \"" + formattedDate
- + "\" for <" + now + ">");
+ + "\" for <" + now + ">");
}
- weekOfYear = cal.get(Calendar.WEEK_OF_YEAR);
+ weekOfYear = cal.get(WEEK_OF_YEAR);
if (weekOfYear != 1) {
errln("Wrong week-of-year " + weekOfYear
- + " for <" + now + ">");
+ + " for <" + now + ">");
}
- cal.set(1997,Calendar.JANUARY,8);
- now=cal.getTime();
+ cal.set(1997, JANUARY, 8);
+ now = cal.getTime();
formattedDate = date.format(now);
if (!formattedDate.equals(standardTime)) {
errln("Wrong display name \"" + formattedDate
- + "\" for <" + now + ">");
+ + "\" for <" + now + ">");
}
- weekOfYear = cal.get(Calendar.WEEK_OF_YEAR);
+ weekOfYear = cal.get(WEEK_OF_YEAR);
if (weekOfYear != 2) {
errln("Wrong week-of-year " + weekOfYear
- + " for <" + now + ">");
+ + " for <" + now + ">");
}
- }
- finally {
+ } finally {
Locale.setDefault(saveLocale);
TimeZone.setDefault(saveZone);
}
@@ -428,9 +450,9 @@
cal1.set( Calendar.MINUTE, 20 );
cal1.set( Calendar.SECOND, 40 ); */
- logln( " Cal1 = " + cal1.getTime().getTime() );
- logln( " Cal1 time in ms = " + cal1.get(Calendar.MILLISECOND) );
- for( int k = 0; k < 100 ; k++ );
+ logln(" Cal1 = " + cal1.getTime().getTime());
+ logln(" Cal1 time in ms = " + cal1.get(MILLISECOND));
+ for (int k = 0; k < 100; k++);
GregorianCalendar cal2 = new GregorianCalendar(1997, 10, 11, 10, 20, 40);
/*cal2.set( Calendar.YEAR, 1997 );
@@ -440,17 +462,19 @@
cal2.set( Calendar.MINUTE, 20 );
cal2.set( Calendar.SECOND, 40 ); */
- logln( " Cal2 = " + cal2.getTime().getTime() );
- logln( " Cal2 time in ms = " + cal2.get(Calendar.MILLISECOND) );
- if( !cal1.equals( cal2 ) )
+ logln(" Cal2 = " + cal2.getTime().getTime());
+ logln(" Cal2 time in ms = " + cal2.get(MILLISECOND));
+ if (!cal1.equals(cal2)) {
errln("Fail: Milliseconds randomized");
+ }
}
public void Test4095407() {
- GregorianCalendar a = new GregorianCalendar(1997,Calendar.NOVEMBER, 13);
- int dow = a.get(Calendar.DAY_OF_WEEK);
- if (dow != Calendar.THURSDAY)
+ GregorianCalendar a = new GregorianCalendar(1997, NOVEMBER, 13);
+ int dow = a.get(DAY_OF_WEEK);
+ if (dow != THURSDAY) {
errln("Fail: Want THURSDAY Got " + dow);
+ }
}
public void Test4096231() {
@@ -461,72 +485,74 @@
Calendar cal1 = new GregorianCalendar(PST);
cal1.setTime(new Date(880698639000L));
int p;
- logln("PST 1 is: " + (p=cal1.get(cal1.HOUR_OF_DAY)));
+ logln("PST 1 is: " + (p = cal1.get(HOUR_OF_DAY)));
cal1.setTimeZone(GMT);
// Issue 1: Changing the timezone doesn't change the
// represented time.
- int h1,h2;
- logln("GMT 1 is: " + (h1=cal1.get(cal1.HOUR_OF_DAY)));
+ int h1, h2;
+ logln("GMT 1 is: " + (h1 = cal1.get(HOUR_OF_DAY)));
cal1.setTime(new Date(880698639000L));
- logln("GMT 2 is: " + (h2=cal1.get(cal1.HOUR_OF_DAY)));
+ logln("GMT 2 is: " + (h2 = cal1.get(HOUR_OF_DAY)));
// Note: This test had a bug in it. It wanted h1!=h2, when
// what was meant was h1!=p. Fixed this concurrent with fix
// to 4177484.
- if (p == h1 || h1 != h2)
+ if (p == h1 || h1 != h2) {
errln("Fail: Hour same in different zones");
+ }
Calendar cal2 = new GregorianCalendar(GMT);
Calendar cal3 = new GregorianCalendar(PST);
- cal2.set(Calendar.MILLISECOND, 0);
- cal3.set(Calendar.MILLISECOND, 0);
+ cal2.set(MILLISECOND, 0);
+ cal3.set(MILLISECOND, 0);
- cal2.set(cal1.get(cal1.YEAR),
- cal1.get(cal1.MONTH),
- cal1.get(cal1.DAY_OF_MONTH),
- cal1.get(cal1.HOUR_OF_DAY),
- cal1.get(cal1.MINUTE),
- cal1.get(cal1.SECOND));
+ cal2.set(cal1.get(YEAR),
+ cal1.get(MONTH),
+ cal1.get(DAY_OF_MONTH),
+ cal1.get(HOUR_OF_DAY),
+ cal1.get(MINUTE),
+ cal1.get(SECOND));
- long t1,t2,t3,t4;
- logln("RGMT 1 is: " + (t1=cal2.getTime().getTime()));
+ long t1, t2, t3, t4;
+ logln("RGMT 1 is: " + (t1 = cal2.getTime().getTime()));
cal3.set(year, month, day, hr, min, sec);
- logln("RPST 1 is: " + (t2=cal3.getTime().getTime()));
+ logln("RPST 1 is: " + (t2 = cal3.getTime().getTime()));
cal3.setTimeZone(GMT);
- logln("RGMT 2 is: " + (t3=cal3.getTime().getTime()));
- cal3.set(cal1.get(cal1.YEAR),
- cal1.get(cal1.MONTH),
- cal1.get(cal1.DAY_OF_MONTH),
- cal1.get(cal1.HOUR_OF_DAY),
- cal1.get(cal1.MINUTE),
- cal1.get(cal1.SECOND));
+ logln("RGMT 2 is: " + (t3 = cal3.getTime().getTime()));
+ cal3.set(cal1.get(YEAR),
+ cal1.get(MONTH),
+ cal1.get(DAY_OF_MONTH),
+ cal1.get(HOUR_OF_DAY),
+ cal1.get(MINUTE),
+ cal1.get(SECOND));
// Issue 2: Calendar continues to use the timezone in its
// constructor for set() conversions, regardless
// of calls to setTimeZone()
- logln("RGMT 3 is: " + (t4=cal3.getTime().getTime()));
- if (t1 == t2 ||
- t1 != t4 ||
- t2 != t3)
+ logln("RGMT 3 is: " + (t4 = cal3.getTime().getTime()));
+ if (t1 == t2
+ || t1 != t4
+ || t2 != t3) {
errln("Fail: Calendar zone behavior faulty");
+ }
}
public void Test4096539() {
- int[] y = {31,28,31,30,31,30,31,31,30,31,30,31};
+ int[] y = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+
+ for (int x = 0; x < 12; x++) {
+ GregorianCalendar gc = new GregorianCalendar(1997, x, y[x]);
+ int m1, m2;
+ log((m1 = gc.get(MONTH) + 1) + "/"
+ + gc.get(DATE) + "/" + gc.get(YEAR)
+ + " + 1mo = ");
- for (int x=0;x<12;x++) {
- GregorianCalendar gc = new
- GregorianCalendar(1997,x,y[x]);
- int m1,m2;
- log((m1=gc.get(Calendar.MONTH)+1)+"/"+
- gc.get(Calendar.DATE)+"/"+gc.get(Calendar.YEAR)+
- " + 1mo = ");
-
- gc.add(Calendar.MONTH, 1);
- logln((m2=gc.get(Calendar.MONTH)+1)+"/"+
- gc.get(Calendar.DATE)+"/"+gc.get(Calendar.YEAR)
- );
+ gc.add(MONTH, 1);
+ logln((m2 = gc.get(MONTH) + 1) + "/"
+ + gc.get(DATE) + "/" + gc.get(YEAR)
+ );
int m = (m1 % 12) + 1;
- if (m2 != m)
+ if (m2 != m) {
errln("Fail: Want " + m + " Got " + m2);
+ }
}
}
@@ -538,13 +564,14 @@
return;
}
- GregorianCalendar cal = (GregorianCalendar)Calendar.getInstance();
- cal.set(Calendar.YEAR, 1997);
- cal.set(Calendar.DAY_OF_YEAR, 1);
+ GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();
+ cal.set(YEAR, 1997);
+ cal.set(DAY_OF_YEAR, 1);
Date d = cal.getTime(); // Should be Jan 1
logln(d.toString());
- if (cal.get(Calendar.DAY_OF_YEAR) != 1)
+ if (cal.get(DAY_OF_YEAR) != 1) {
errln("Fail: DAY_OF_YEAR not set");
+ }
}
public void Test4103271() {
@@ -555,28 +582,28 @@
}
SimpleDateFormat sdf = new SimpleDateFormat();
- int numYears=40, startYear=1997, numDays=15;
+ int numYears = 40, startYear = 1997, numDays = 15;
String output, testDesc;
- GregorianCalendar testCal = (GregorianCalendar)Calendar.getInstance();
+ GregorianCalendar testCal = (GregorianCalendar) Calendar.getInstance();
testCal.clear();
sdf.setCalendar(testCal);
sdf.applyPattern("d MMM yyyy");
boolean fail = false;
- for (int firstDay=1; firstDay<=2; firstDay++) {
- for (int minDays=1; minDays<=7; minDays++) {
+ for (int firstDay = 1; firstDay <= 2; firstDay++) {
+ for (int minDays = 1; minDays <= 7; minDays++) {
testCal.setMinimalDaysInFirstWeek(minDays);
testCal.setFirstDayOfWeek(firstDay);
testDesc = ("Test" + String.valueOf(firstDay) + String.valueOf(minDays));
- logln(testDesc + " => 1st day of week=" +
- String.valueOf(firstDay) +
- ", minimum days in first week=" +
- String.valueOf(minDays));
- for (int j=startYear; j<=startYear+numYears; j++) {
- testCal.set(j,11,25);
- for(int i=0; i<numDays; i++) {
- testCal.add(Calendar.DATE,1);
+ logln(testDesc + " => 1st day of week="
+ + String.valueOf(firstDay)
+ + ", minimum days in first week="
+ + String.valueOf(minDays));
+ for (int j = startYear; j <= startYear + numYears; j++) {
+ testCal.set(j, 11, 25);
+ for (int i = 0; i < numDays; i++) {
+ testCal.add(DATE, 1);
String calWOY;
- int actWOY = testCal.get(Calendar.WEEK_OF_YEAR);
+ int actWOY = testCal.get(WEEK_OF_YEAR);
if (actWOY < 1 || actWOY > 53) {
Date d = testCal.getTime();
calWOY = String.valueOf(actWOY);
@@ -592,20 +619,19 @@
int[] DATA = {
3, 52, 52, 52, 52, 52, 52, 52,
- 1, 1, 1, 1, 1, 1, 1,
- 2, 2, 2, 2, 2, 2, 2,
+ 1, 1, 1, 1, 1, 1, 1,
+ 2, 2, 2, 2, 2, 2, 2,
4, 52, 52, 52, 52, 52, 52, 52,
- 53, 53, 53, 53, 53, 53, 53,
- 1, 1, 1, 1, 1, 1, 1,
- };
- testCal.setFirstDayOfWeek(Calendar.SUNDAY);
- for (int j=0; j<DATA.length; j+=22) {
- logln("Minimal days in first week = " + DATA[j] +
- " Week starts on Sunday");
+ 53, 53, 53, 53, 53, 53, 53,
+ 1, 1, 1, 1, 1, 1, 1};
+ testCal.setFirstDayOfWeek(SUNDAY);
+ for (int j = 0; j < DATA.length; j += 22) {
+ logln("Minimal days in first week = " + DATA[j]
+ + " Week starts on Sunday");
testCal.setMinimalDaysInFirstWeek(DATA[j]);
- testCal.set(1997, Calendar.DECEMBER, 21);
- for (int i=0; i<21; ++i) {
- int woy = testCal.get(Calendar.WEEK_OF_YEAR);
+ testCal.set(1997, DECEMBER, 21);
+ for (int i = 0; i < 21; ++i) {
+ int woy = testCal.get(WEEK_OF_YEAR);
log("\t" + testCal.getTime() + " " + woy);
if (woy != DATA[j + 1 + i]) {
log(" ERROR");
@@ -618,47 +644,47 @@
// get the same answer back. This is a round-trip test.
Date save = testCal.getTime();
testCal.clear();
- testCal.set(Calendar.YEAR, DATA[j+1+i] < 25 ? 1998 : 1997);
- testCal.set(Calendar.WEEK_OF_YEAR, DATA[j+1+i]);
- testCal.set(Calendar.DAY_OF_WEEK, (i%7) + Calendar.SUNDAY);
+ testCal.set(YEAR, DATA[j + 1 + i] < 25 ? 1998 : 1997);
+ testCal.set(WEEK_OF_YEAR, DATA[j + 1 + i]);
+ testCal.set(DAY_OF_WEEK, (i % 7) + SUNDAY);
if (!testCal.getTime().equals(save)) {
logln(" Parse failed: " + testCal.getTime());
- fail= true;
+ fail = true;
} else {
logln(" Passed");
}
testCal.setTime(save);
- testCal.add(Calendar.DAY_OF_MONTH, 1);
+ testCal.add(DAY_OF_MONTH, 1);
}
}
// Test field disambiguation with a few special hard-coded cases.
// This shouldn't fail if the above cases aren't failing.
+ @SuppressWarnings("deprecation")
Object[] DISAM = {
- new Integer(1998), new Integer(1), new Integer(Calendar.SUNDAY),
- new Date(97, Calendar.DECEMBER, 28),
- new Integer(1998), new Integer(2), new Integer(Calendar.SATURDAY),
- new Date(98, Calendar.JANUARY, 10),
- new Integer(1998), new Integer(53), new Integer(Calendar.THURSDAY),
- new Date(98, Calendar.DECEMBER, 31),
- new Integer(1998), new Integer(53), new Integer(Calendar.FRIDAY),
- new Date(99, Calendar.JANUARY, 1),
- };
+ 1998, 1, SUNDAY,
+ new Date(97, DECEMBER, 28),
+ 1998, 2, SATURDAY,
+ new Date(98, JANUARY, 10),
+ 1998, 53, THURSDAY,
+ new Date(98, DECEMBER, 31),
+ 1998, 53, FRIDAY,
+ new Date(99, JANUARY, 1)};
testCal.setMinimalDaysInFirstWeek(3);
- testCal.setFirstDayOfWeek(Calendar.SUNDAY);
- for (int i=0; i<DISAM.length; i+=4) {
- int y = ((Integer)DISAM[i]).intValue();
- int woy = ((Integer)DISAM[i+1]).intValue();
- int dow = ((Integer)DISAM[i+2]).intValue();
- Date exp = (Date)DISAM[i+3];
+ testCal.setFirstDayOfWeek(SUNDAY);
+ for (int i = 0; i < DISAM.length; i += 4) {
+ int y = (Integer) DISAM[i];
+ int woy = (Integer) DISAM[i + 1];
+ int dow = (Integer) DISAM[i + 2];
+ Date exp = (Date) DISAM[i + 3];
testCal.clear();
- testCal.set(Calendar.YEAR, y);
- testCal.set(Calendar.WEEK_OF_YEAR, woy);
- testCal.set(Calendar.DAY_OF_WEEK, dow);
+ testCal.set(YEAR, y);
+ testCal.set(WEEK_OF_YEAR, woy);
+ testCal.set(DAY_OF_WEEK, dow);
log(y + "-W" + woy + "-DOW" + dow);
if (!testCal.getTime().equals(exp)) {
- logln(" FAILED expect: " + exp + "\n got: " +testCal.getTime());
+ logln(" FAILED expect: " + exp + "\n got: " + testCal.getTime());
fail = true;
} else {
logln(" OK");
@@ -668,47 +694,51 @@
// Now try adding and rolling
Object ADD = new Object();
Object ROLL = new Object();
+ @SuppressWarnings("deprecation")
Object[] ADDROLL = {
- ADD, new Integer(1), new Date(98, Calendar.DECEMBER, 25), new Date(99, Calendar.JANUARY, 1),
- ADD, new Integer(1), new Date(97, Calendar.DECEMBER, 28), new Date(98, Calendar.JANUARY, 4),
- ROLL, new Integer(1), new Date(98, Calendar.DECEMBER, 27), new Date(98, Calendar.JANUARY, 4),
- ROLL, new Integer(1), new Date(99, Calendar.DECEMBER, 24), new Date(99, Calendar.DECEMBER, 31),
- ROLL, new Integer(1), new Date(99, Calendar.DECEMBER, 25), new Date(99, Calendar.JANUARY, 9),
- };
+ ADD, 1, new Date(98, DECEMBER, 25), new Date(99, JANUARY, 1),
+ ADD, 1, new Date(97, DECEMBER, 28), new Date(98, JANUARY, 4),
+ ROLL, 1, new Date(98, DECEMBER, 27), new Date(98, JANUARY, 4),
+ ROLL, 1, new Date(99, DECEMBER, 24), new Date(99, DECEMBER, 31),
+ ROLL, 1, new Date(99, DECEMBER, 25), new Date(99, JANUARY, 9)};
testCal.setMinimalDaysInFirstWeek(3);
- testCal.setFirstDayOfWeek(Calendar.SUNDAY);
- for (int i=0; i<ADDROLL.length; i+=4) {
- int amount = ((Integer)ADDROLL[i+1]).intValue();
- Date before = (Date)ADDROLL[i+2];
- Date after = (Date)ADDROLL[i+3];
+ testCal.setFirstDayOfWeek(SUNDAY);
+ for (int i = 0; i < ADDROLL.length; i += 4) {
+ int amount = (Integer) ADDROLL[i + 1];
+ Date before = (Date) ADDROLL[i + 2];
+ Date after = (Date) ADDROLL[i + 3];
testCal.setTime(before);
- if (ADDROLL[i] == ADD)
- testCal.add(Calendar.WEEK_OF_YEAR, amount);
- else
- testCal.roll(Calendar.WEEK_OF_YEAR, amount);
- log((ADDROLL[i]==ADD ? "add(WOY," : "roll(WOY,") +
- amount + ")\t " + before +
- "\n\t\t => " + testCal.getTime());
+ if (ADDROLL[i] == ADD) {
+ testCal.add(WEEK_OF_YEAR, amount);
+ } else {
+ testCal.roll(WEEK_OF_YEAR, amount);
+ }
+ log((ADDROLL[i] == ADD ? "add(WOY," : "roll(WOY,")
+ + amount + ")\t " + before
+ + "\n\t\t => " + testCal.getTime());
if (!after.equals(testCal.getTime())) {
logln("\tFAIL\n\t\texp: " + after);
fail = true;
- } else
+ } else {
logln(" OK");
+ }
testCal.setTime(after);
- if (ADDROLL[i] == ADD)
- testCal.add(Calendar.WEEK_OF_YEAR, -amount);
- else
- testCal.roll(Calendar.WEEK_OF_YEAR, -amount);
- log((ADDROLL[i]==ADD ? "add(WOY," : "roll(WOY,") +
- (-amount) + ") " + after +
- "\n\t\t => " + testCal.getTime());
+ if (ADDROLL[i] == ADD) {
+ testCal.add(WEEK_OF_YEAR, -amount);
+ } else {
+ testCal.roll(WEEK_OF_YEAR, -amount);
+ }
+ log((ADDROLL[i] == ADD ? "add(WOY," : "roll(WOY,")
+ + (-amount) + ") " + after
+ + "\n\t\t => " + testCal.getTime());
if (!before.equals(testCal.getTime())) {
logln("\tFAIL\n\t\texp: " + before);
fail = true;
+ } else {
+ logln("\tOK");
}
- else logln("\tOK");
}
if (fail) {
@@ -719,63 +749,68 @@
public void Test4106136() {
Locale saveLocale = Locale.getDefault();
try {
- Locale[] locales = { Locale.CHINESE, Locale.CHINA };
- for (int i=0; i<locales.length; ++i) {
+ Locale[] locales = {Locale.CHINESE, Locale.CHINA};
+ for (int i = 0; i < locales.length; ++i) {
Locale.setDefault(locales[i]);
int[] n = {
- Calendar.getAvailableLocales().length,
+ getAvailableLocales().length,
DateFormat.getAvailableLocales().length,
- NumberFormat.getAvailableLocales().length
- };
- for (int j=0; j<n.length; ++j) {
+ NumberFormat.getAvailableLocales().length};
+ for (int j = 0; j < n.length; ++j) {
if (n[j] == 0) {
errln("Fail: No locales for " + locales[i]);
}
}
}
- }
- finally {
+ } finally {
Locale.setDefault(saveLocale);
}
}
+ @SuppressWarnings("deprecation")
public void Test4108764() {
- Date d00 = new Date(97, Calendar.MARCH, 15, 12, 00, 00);
- Date d01 = new Date(97, Calendar.MARCH, 15, 12, 00, 56);
- Date d10 = new Date(97, Calendar.MARCH, 15, 12, 34, 00);
- Date d11 = new Date(97, Calendar.MARCH, 15, 12, 34, 56);
- Date epoch = new Date(70, Calendar.JANUARY, 1);
+ Date d00 = new Date(97, MARCH, 15, 12, 00, 00);
+ Date d01 = new Date(97, MARCH, 15, 12, 00, 56);
+ Date d10 = new Date(97, MARCH, 15, 12, 34, 00);
+ Date d11 = new Date(97, MARCH, 15, 12, 34, 56);
+ Date epoch = new Date(70, JANUARY, 1);
Calendar cal = Calendar.getInstance();
cal.setTime(d11);
- cal.clear( Calendar.MINUTE );
+ cal.clear(MINUTE);
logln(cal.getTime().toString());
- if (!cal.getTime().equals(d01))
+ if (!cal.getTime().equals(d01)) {
errln("Fail: clear(MINUTE) broken");
+ }
- cal.set( Calendar.SECOND, 0 );
+ cal.set(SECOND, 0);
logln(cal.getTime().toString());
- if (!cal.getTime().equals(d00))
+ if (!cal.getTime().equals(d00)) {
errln("Fail: set(SECOND, 0) broken");
+ }
cal.setTime(d11);
- cal.set( Calendar.SECOND, 0 );
+ cal.set(SECOND, 0);
logln(cal.getTime().toString());
- if (!cal.getTime().equals(d10))
+ if (!cal.getTime().equals(d10)) {
errln("Fail: set(SECOND, 0) broken #2");
+ }
- cal.clear( Calendar.MINUTE );
+ cal.clear(MINUTE);
logln(cal.getTime().toString());
- if (!cal.getTime().equals(d00))
+ if (!cal.getTime().equals(d00)) {
errln("Fail: clear(MINUTE) broken #2");
+ }
cal.clear();
logln(cal.getTime().toString());
- if (!cal.getTime().equals(epoch))
+ if (!cal.getTime().equals(epoch)) {
errln("Fail: clear() broken Want " + epoch);
+ }
}
+ @SuppressWarnings("deprecation")
public void Test4114578() {
Locale locale = Locale.getDefault();
if (!TestUtils.usesGregorianCalendar(locale)) {
@@ -783,14 +818,14 @@
return;
}
- int ONE_HOUR = 60*60*1000;
+ int ONE_HOUR = 60 * 60 * 1000;
TimeZone saveZone = TimeZone.getDefault();
boolean fail = false;
try {
TimeZone.setDefault(TimeZone.getTimeZone("PST"));
Calendar cal = Calendar.getInstance();
- long onset = new Date(98, Calendar.APRIL, 5, 1, 0).getTime() + ONE_HOUR;
- long cease = new Date(98, Calendar.OCTOBER, 25, 0, 0).getTime() + 2*ONE_HOUR;
+ long onset = new Date(98, APRIL, 5, 1, 0).getTime() + ONE_HOUR;
+ long cease = new Date(98, OCTOBER, 25, 0, 0).getTime() + 2 * ONE_HOUR;
final int ADD = 1;
final int ROLL = 2;
@@ -807,26 +842,25 @@
// time value may jump 2 hours by skipping non-existent wall-clock time.
// Note that JDK-4114578 was a problem of add(), not roll().
cease - ONE_HOUR, ROLL, 1, ONE_HOUR * 2,
- cease, ROLL, -1, -ONE_HOUR * 2,
- };
+ cease, ROLL, -1, -ONE_HOUR * 2};
- for (int i=0; i<DATA.length; i+=4) {
+ for (int i = 0; i < DATA.length; i += 4) {
Date date = new Date(DATA[i]);
- int amt = (int) DATA[i+2];
- long expectedChange = DATA[i+3];
+ int amt = (int) DATA[i + 2];
+ long expectedChange = DATA[i + 3];
log(date.toString());
cal.setTime(date);
- switch ((int) DATA[i+1]) {
- case ADD:
- log(" add (HOUR," + (amt<0?"":"+")+amt + ")= ");
- cal.add(Calendar.HOUR, amt);
- break;
- case ROLL:
- log(" roll(HOUR," + (amt<0?"":"+")+amt + ")= ");
- cal.roll(Calendar.HOUR, amt);
- break;
+ switch ((int) DATA[i + 1]) {
+ case ADD:
+ log(" add (HOUR," + (amt < 0 ? "" : "+") + amt + ")= ");
+ cal.add(HOUR, amt);
+ break;
+ case ROLL:
+ log(" roll(HOUR," + (amt < 0 ? "" : "+") + amt + ")= ");
+ cal.roll(HOUR, amt);
+ break;
}
log(cal.getTime().toString());
@@ -835,8 +869,9 @@
if (change != expectedChange) {
fail = true;
logln(" FAIL");
+ } else {
+ logln(" OK");
}
- else logln(" OK");
}
} finally {
TimeZone.setDefault(saveZone);
@@ -852,10 +887,11 @@
*/
public void Test4118384() {
Calendar cal = Calendar.getInstance();
- if (cal.getMaximum(Calendar.HOUR) != 11 ||
- cal.getLeastMaximum(Calendar.HOUR) != 11 ||
- cal.getActualMaximum(Calendar.HOUR) != 11)
+ if (cal.getMaximum(HOUR) != 11
+ || cal.getLeastMaximum(HOUR) != 11
+ || cal.getActualMaximum(HOUR) != 11) {
errln("Fail: maximum of HOUR field should be 11");
+ }
}
/**
@@ -871,13 +907,14 @@
GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();
DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");
cal.clear();
- for (int y=-20; y<=10; ++y) {
- cal.set(Calendar.ERA, y < 1 ? GregorianCalendar.BC : GregorianCalendar.AD);
- cal.set(Calendar.YEAR, y < 1 ? 1 - y : y);
- logln(y + " = " + fmt.format(cal.getTime()) + " " +
- cal.isLeapYear(y));
- if (cal.isLeapYear(y) != ((y+40)%4 == 0))
+ for (int y = -20; y <= 10; ++y) {
+ cal.set(ERA, y < 1 ? GregorianCalendar.BC : GregorianCalendar.AD);
+ cal.set(YEAR, y < 1 ? 1 - y : y);
+ logln(y + " = " + fmt.format(cal.getTime()) + " "
+ + cal.isLeapYear(y));
+ if (cal.isLeapYear(y) != ((y + 40) % 4 == 0)) {
errln("Leap years broken");
+ }
}
}
@@ -895,14 +932,15 @@
GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance();
DateFormat fmt = new SimpleDateFormat("MMMM d, yyyy G");
cal.clear();
- cal.set(Calendar.ERA, GregorianCalendar.BC);
- cal.set(Calendar.YEAR, 81); // 81 BC is a leap year (proleptically)
- cal.set(Calendar.MONTH, Calendar.FEBRUARY);
- cal.set(Calendar.DATE, 28);
- cal.add(Calendar.DATE, 1);
- if (cal.get(Calendar.DATE) != 29 ||
- !cal.isLeapYear(-80)) // -80 == 81 BC
+ cal.set(ERA, GregorianCalendar.BC);
+ cal.set(YEAR, 81); // 81 BC is a leap year (proleptically)
+ cal.set(MONTH, FEBRUARY);
+ cal.set(DATE, 28);
+ cal.add(DATE, 1);
+ if (cal.get(DATE) != 29
+ || !cal.isLeapYear(-80)) { // -80 == 81 BC
errln("Calendar not proleptic");
+ }
}
/**
@@ -912,16 +950,16 @@
*/
public void Test4136399() {
/* Note: This test is actually more strict than it has to be.
- * Technically, there is no requirement that unequal objects have
- * unequal hashes. We only require equal objects to have equal hashes.
- * It is desirable for unequal objects to have distributed hashes, but
- * there is no hard requirement here.
- *
- * In this test we make assumptions about certain attributes of calendar
- * objects getting represented in the hash, which need not always be the
- * case (although it does work currently with the given test). */
+ * Technically, there is no requirement that unequal objects have
+ * unequal hashes. We only require equal objects to have equal hashes.
+ * It is desirable for unequal objects to have distributed hashes, but
+ * there is no hard requirement here.
+ *
+ * In this test we make assumptions about certain attributes of calendar
+ * objects getting represented in the hash, which need not always be the
+ * case (although it does work currently with the given test). */
Calendar a = Calendar.getInstance();
- Calendar b = (Calendar)a.clone();
+ Calendar b = (Calendar) a.clone();
if (a.hashCode() != b.hashCode()) {
errln("Calendar hash code unequal for cloned objects");
}
@@ -946,19 +984,19 @@
// Assume getTimeZone() returns a reference, not a clone
// of a reference -- this is true as of this writing
- b.getTimeZone().setRawOffset(a.getTimeZone().getRawOffset() + 60*60*1000);
+ b.getTimeZone().setRawOffset(a.getTimeZone().getRawOffset() + 60 * 60 * 1000);
if (a.hashCode() == b.hashCode()) {
errln("Calendar hash code ignores zone");
}
b.getTimeZone().setRawOffset(a.getTimeZone().getRawOffset());
GregorianCalendar c = new GregorianCalendar();
- GregorianCalendar d = (GregorianCalendar)c.clone();
+ GregorianCalendar d = (GregorianCalendar) c.clone();
if (c.hashCode() != d.hashCode()) {
errln("GregorianCalendar hash code unequal for clones objects");
}
Date cutover = c.getGregorianChange();
- d.setGregorianChange(new Date(cutover.getTime() + 24*60*60*1000));
+ d.setGregorianChange(new Date(cutover.getTime() + 24 * 60 * 60 * 1000));
if (c.hashCode() == d.hashCode()) {
errln("GregorianCalendar hash code ignores cutover");
}
@@ -969,9 +1007,9 @@
*/
public void Test4141665() {
GregorianCalendar cal = new GregorianCalendar();
- GregorianCalendar cal2 = (GregorianCalendar)cal.clone();
+ GregorianCalendar cal2 = (GregorianCalendar) cal.clone();
Date cut = cal.getGregorianChange();
- Date cut2 = new Date(cut.getTime() + 100*24*60*60*1000L); // 100 days later
+ Date cut2 = new Date(cut.getTime() + 100 * 24 * 60 * 60 * 1000L); // 100 days later
if (!cal.equals(cal2)) {
errln("Cloned GregorianCalendars not equal");
}
@@ -990,12 +1028,10 @@
try {
calendar.roll(-1, true);
errln("Test failed, no exception trown");
- }
- catch (IllegalArgumentException e) {
+ } catch (IllegalArgumentException e) {
// OK: Do nothing
// logln("Test passed");
- }
- catch (Exception e) {
+ } catch (Exception e) {
errln("Test failed. Unexpected exception is thrown: " + e);
e.printStackTrace();
}
@@ -1014,12 +1050,12 @@
calendar.setTimeZone(TimeZone.getTimeZone("GMT"));
calendar.setTime(new Date(Long.MIN_VALUE));
- int year1 = calendar.get(Calendar.YEAR);
- int era1 = calendar.get(Calendar.ERA);
+ int year1 = calendar.get(YEAR);
+ int era1 = calendar.get(ERA);
calendar.setTime(new Date(Long.MAX_VALUE));
- int year2 = calendar.get(Calendar.YEAR);
- int era2 = calendar.get(Calendar.ERA);
+ int year2 = calendar.get(YEAR);
+ int era2 = calendar.get(ERA);
if (year1 == year2 && era1 == era2) {
errln("Fail: Long.MIN_VALUE or Long.MAX_VALUE wrapping around");
@@ -1032,14 +1068,14 @@
public void Test4145983() {
GregorianCalendar calendar = new GregorianCalendar();
calendar.setTimeZone(TimeZone.getTimeZone("GMT"));
- Date[] DATES = { new Date(Long.MAX_VALUE), new Date(Long.MIN_VALUE) };
- for (int i=0; i<DATES.length; ++i) {
+ Date[] DATES = {new Date(Long.MAX_VALUE), new Date(Long.MIN_VALUE)};
+ for (int i = 0; i < DATES.length; ++i) {
calendar.setTime(DATES[i]);
- int year = calendar.get(Calendar.YEAR);
- int maxYear = calendar.getMaximum(Calendar.YEAR);
+ int year = calendar.get(YEAR);
+ int maxYear = calendar.getMaximum(YEAR);
if (year > maxYear) {
- errln("Failed for "+DATES[i].getTime()+" ms: year=" +
- year + ", maxYear=" + maxYear);
+ errln("Failed for " + DATES[i].getTime() + " ms: year="
+ + year + ", maxYear=" + maxYear);
}
}
}
@@ -1068,28 +1104,29 @@
"SECOND",
"MILLISECOND",
"ZONE_OFFSET",
- "DST_OFFSET"
- };
+ "DST_OFFSET"};
GregorianCalendar calendar = new GregorianCalendar();
calendar.setLenient(false);
- Date date = new Date(1996-1900, Calendar.JANUARY, 3); // Arbitrary date
- for (int field = 0; field < Calendar.FIELD_COUNT; field++) {
+ @SuppressWarnings("deprecation")
+ Date date = new Date(1996 - 1900, JANUARY, 3); // Arbitrary date
+ for (int field = 0; field < FIELD_COUNT; field++) {
calendar.setTime(date);
// Note: In the bug report, getActualMaximum() was called instead
// of getMaximum() -- this was an error. The validation code doesn't
// use getActualMaximum(), since that's too costly.
int max = calendar.getMaximum(field);
- int value = max+1;
+ int value = max + 1;
calendar.set(field, value);
try {
calendar.getTime(); // Force time computation
// We expect an exception to be thrown. If we fall through
// to the next line, then we have a bug.
- errln("Test failed with field " + fieldName[field] +
- ", date before: " + date +
- ", date after: " + calendar.getTime() +
- ", value: " + value + " (max = " + max +")");
- } catch (IllegalArgumentException e) {}
+ errln("Test failed with field " + fieldName[field]
+ + ", date before: " + date
+ + ", date after: " + calendar.getTime()
+ + ", value: " + value + " (max = " + max + ")");
+ } catch (IllegalArgumentException e) {
+ }
}
}
@@ -1099,19 +1136,19 @@
* CANNOT REPRODUCE THIS BUG
*/
public void Test4149677() {
- TimeZone[] zones = { TimeZone.getTimeZone("GMT"),
- TimeZone.getTimeZone("PST"),
- TimeZone.getTimeZone("EAT") };
- for (int i=0; i<zones.length; ++i) {
+ TimeZone[] zones = {TimeZone.getTimeZone("GMT"),
+ TimeZone.getTimeZone("PST"),
+ TimeZone.getTimeZone("EAT")};
+ for (int i = 0; i < zones.length; ++i) {
GregorianCalendar calendar = new GregorianCalendar(zones[i]);
// Make sure extreme values don't wrap around
calendar.setTime(new Date(Long.MIN_VALUE));
- if (calendar.get(Calendar.ERA) != GregorianCalendar.BC) {
+ if (calendar.get(ERA) != GregorianCalendar.BC) {
errln("Fail: Date(Long.MIN_VALUE) has an AD year in " + zones[i]);
}
calendar.setTime(new Date(Long.MAX_VALUE));
- if (calendar.get(Calendar.ERA) != GregorianCalendar.AD) {
+ if (calendar.get(ERA) != GregorianCalendar.AD) {
errln("Fail: Date(Long.MAX_VALUE) has a BC year in " + zones[i]);
}
@@ -1139,23 +1176,25 @@
Date d;
try {
- for (int i=0; i<5; ++i) {
- if (i>0) logln("---");
+ for (int i = 0; i < 5; ++i) {
+ if (i > 0) {
+ logln("---");
+ }
cal.clear();
- cal.set(1998, Calendar.APRIL, 5, i, 0);
+ cal.set(1998, APRIL, 5, i, 0);
d = cal.getTime();
String s0 = d.toString();
logln("0 " + i + ": " + s0);
cal.clear();
- cal.set(1998, Calendar.APRIL, 4, i+24, 0);
+ cal.set(1998, APRIL, 4, i + 24, 0);
d = cal.getTime();
String sPlus = d.toString();
logln("+ " + i + ": " + sPlus);
cal.clear();
- cal.set(1998, Calendar.APRIL, 6, i-24, 0);
+ cal.set(1998, APRIL, 6, i - 24, 0);
d = cal.getTime();
String sMinus = d.toString();
logln("- " + i + ": " + sMinus);
@@ -1164,8 +1203,7 @@
errln("Fail: All three lines must match");
}
}
- }
- finally {
+ } finally {
TimeZone.setDefault(savedTz);
}
}
@@ -1174,14 +1212,14 @@
* Adding 12 months behaves differently from adding 1 year
*/
public void Test4165343() {
- GregorianCalendar calendar = new GregorianCalendar(1996, Calendar.FEBRUARY, 29);
+ GregorianCalendar calendar = new GregorianCalendar(1996, FEBRUARY, 29);
Date start = calendar.getTime();
logln("init date: " + start);
- calendar.add(Calendar.MONTH, 12);
+ calendar.add(MONTH, 12);
Date date1 = calendar.getTime();
logln("after adding 12 months: " + date1);
calendar.setTime(start);
- calendar.add(Calendar.YEAR, 1);
+ calendar.add(YEAR, 1);
Date date2 = calendar.getTime();
logln("after adding one year : " + date2);
if (date1.equals(date2)) {
@@ -1196,34 +1234,34 @@
*/
public void Test4166109() {
/* Test month:
- *
- * March 1998
- * Su Mo Tu We Th Fr Sa
- * 1 2 3 4 5 6 7
- * 8 9 10 11 12 13 14
- * 15 16 17 18 19 20 21
- * 22 23 24 25 26 27 28
- * 29 30 31
+ *
+ * March 1998
+ * Su Mo Tu We Th Fr Sa
+ * 1 2 3 4 5 6 7
+ * 8 9 10 11 12 13 14
+ * 15 16 17 18 19 20 21
+ * 22 23 24 25 26 27 28
+ * 29 30 31
*/
boolean passed = true;
- int field = Calendar.WEEK_OF_MONTH;
+ int field = WEEK_OF_MONTH;
GregorianCalendar calendar = new GregorianCalendar(Locale.US);
- calendar.set(1998, Calendar.MARCH, 1);
+ calendar.set(1998, MARCH, 1);
calendar.setMinimalDaysInFirstWeek(1);
logln("Date: " + calendar.getTime());
- int firstInMonth = calendar.get(Calendar.DAY_OF_MONTH);
+ int firstInMonth = calendar.get(DAY_OF_MONTH);
- for (int firstInWeek = Calendar.SUNDAY; firstInWeek <= Calendar.SATURDAY; firstInWeek++) {
+ for (int firstInWeek = SUNDAY; firstInWeek <= SATURDAY; firstInWeek++) {
calendar.setFirstDayOfWeek(firstInWeek);
int returned = calendar.getActualMaximum(field);
- int expected = (31 + ((firstInMonth - firstInWeek + 7)% 7) + 6) / 7;
+ int expected = (31 + ((firstInMonth - firstInWeek + 7) % 7) + 6) / 7;
- logln("First day of week = " + firstInWeek +
- " getActualMaximum(WEEK_OF_MONTH) = " + returned +
- " expected = " + expected +
- ((returned == expected) ? " ok" : " FAIL"));
+ logln("First day of week = " + firstInWeek
+ + " getActualMaximum(WEEK_OF_MONTH) = " + returned
+ + " expected = " + expected
+ + ((returned == expected) ? " ok" : " FAIL"));
if (returned != expected) {
passed = false;
@@ -1242,19 +1280,19 @@
* changed. See 4928615.
*/
public void Test4167060() {
- int field = Calendar.YEAR;
+ int field = YEAR;
DateFormat format = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy G",
- Locale.US);
+ Locale.US);
int[][] dates = {
// year, month, day of month
- { 100, Calendar.NOVEMBER, 1 },
- { -99 /*100BC*/, Calendar.JANUARY, 1 },
- { 1996, Calendar.FEBRUARY, 29 }};
+ {100, NOVEMBER, 1},
+ {-99 /*100BC*/, JANUARY, 1},
+ {1996, FEBRUARY, 29}};
- String[] id = { "Hybrid", "Gregorian", "Julian" };
+ String[] id = {"Hybrid", "Gregorian", "Julian"};
- for (int k=0; k<3; ++k) {
+ for (int k = 0; k < 3; ++k) {
logln("--- " + id[k] + " ---");
for (int j = 0; j < dates.length; ++j) {
@@ -1265,7 +1303,7 @@
calendar.setGregorianChange(new Date(Long.MAX_VALUE));
}
calendar.set(dates[j][0], dates[j][1], dates[j][2]);
- format.setCalendar((Calendar)calendar.clone());
+ format.setCalendar((Calendar) calendar.clone());
Date dateBefore = calendar.getTime();
@@ -1273,7 +1311,7 @@
logln("maxYear: " + maxYear + " for " + format.format(calendar.getTime()));
logln("date before: " + format.format(dateBefore));
- int years[] = {2000, maxYear-1, maxYear, maxYear+1};
+ int[] years = {2000, maxYear - 1, maxYear, maxYear + 1};
for (int i = 0; i < years.length; i++) {
boolean valid = years[i] <= maxYear;
@@ -1282,8 +1320,8 @@
int newYear = calendar.get(field);
calendar.setTime(dateBefore); // restore calendar for next use
- logln(" Year " + years[i] + (valid? " ok " : " bad") +
- " => " + format.format(dateAfter));
+ logln(" Year " + years[i] + (valid ? " ok " : " bad")
+ + " => " + format.format(dateAfter));
if (valid && newYear != years[i]) {
errln(" FAIL: " + newYear + " should be valid; date, month and time shouldn't change");
} else if (!valid && newYear == years[i]) {
@@ -1305,18 +1343,16 @@
return;
}
- int fieldsList[][] = {
- { 1997, Calendar.FEBRUARY, 1, 10, 45, 15, 900 },
- { 1999, Calendar.DECEMBER, 22, 23, 59, 59, 999 },
+ int[][] fieldsList = {
+ {1997, FEBRUARY, 1, 10, 45, 15, 900},
+ {1999, DECEMBER, 22, 23, 59, 59, 999},
// test case for 4960642 with default cutover
- { 1582, Calendar.OCTOBER, 4, 23, 59, 59, 999 },
- };
+ {1582, OCTOBER, 4, 23, 59, 59, 999}};
String[] fieldNames = {
"ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH",
"DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK", "DAY_OF_WEEK_IN_MONTH",
"AM_PM", "HOUR", "HOUR_OF_DAY", "MINUTE", "SECOND", "MILLISECOND",
- "ZONE_OFFSET", "DST_OFFSET"
- };
+ "ZONE_OFFSET", "DST_OFFSET"};
Locale savedLocale = Locale.getDefault();
Locale.setDefault(Locale.US);
@@ -1326,25 +1362,25 @@
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(new Date(0));
- cal.roll(Calendar.HOUR, 0x7F000000);
- cal.roll(Calendar.HOUR, -0x7F000000);
+ cal.roll(HOUR, 0x7F000000);
+ cal.roll(HOUR, -0x7F000000);
if (cal.getTime().getTime() != 0) {
- errln("Hour rolling broken. expected 0, got "+cal.getTime().getTime());
+ errln("Hour rolling broken. expected 0, got " + cal.getTime().getTime());
}
- for (int op=0; op<2; ++op) {
- logln("Testing GregorianCalendar " + (op==0 ? "add" : "roll"));
+ for (int op = 0; op < 2; ++op) {
+ logln("Testing GregorianCalendar " + (op == 0 ? "add" : "roll"));
- for (int field=0; field < Calendar.FIELD_COUNT; ++field) {
- if (field != Calendar.ZONE_OFFSET &&
- field != Calendar.DST_OFFSET) {
- for (int j=0; j<fieldsList.length; ++j) {
- int fields[] = fieldsList[j];
+ for (int field = 0; field < FIELD_COUNT; ++field) {
+ if (field != ZONE_OFFSET
+ && field != DST_OFFSET) {
+ for (int j = 0; j < fieldsList.length; ++j) {
+ int[] fields = fieldsList[j];
cal.clear();
cal.set(fields[0], fields[1], fields[2],
fields[3], fields[4], fields[5]);
- cal.set(Calendar.MILLISECOND, fields[6]);
- for (int i = 0; i < 2*limit; i++) {
+ cal.set(MILLISECOND, fields[6]);
+ for (int i = 0; i < 2 * limit; i++) {
if (op == 0) {
cal.add(field, i < limit ? 1 : -1);
} else {
@@ -1352,45 +1388,45 @@
}
}
- if (cal.get(Calendar.YEAR) != fields[0] ||
- cal.get(Calendar.MONTH) != fields[1] ||
- cal.get(Calendar.DATE) != fields[2] ||
- cal.get(Calendar.HOUR_OF_DAY) != fields[3] ||
- cal.get(Calendar.MINUTE) != fields[4] ||
- cal.get(Calendar.SECOND) != fields[5] ||
- cal.get(Calendar.MILLISECOND) != fields[6]) {
- errln("Field " + field +
- " (" + fieldNames[field] +
- ") FAIL, expected " +
- fields[0] +
- "/" + (fields[1] + 1) +
- "/" + fields[2] +
- " " + fields[3] +
- ":" + fields[4] +
- ":" + fields[5] +
- "." + fields[6] +
- ", got " + cal.get(Calendar.YEAR) +
- "/" + (cal.get(Calendar.MONTH) + 1) +
- "/" + cal.get(Calendar.DATE) +
- " " + cal.get(Calendar.HOUR_OF_DAY) +
- ":" + cal.get(Calendar.MINUTE) +
- ":" + cal.get(Calendar.SECOND) +
- "." + cal.get(Calendar.MILLISECOND));
+ if (cal.get(YEAR) != fields[0]
+ || cal.get(MONTH) != fields[1]
+ || cal.get(DATE) != fields[2]
+ || cal.get(HOUR_OF_DAY) != fields[3]
+ || cal.get(MINUTE) != fields[4]
+ || cal.get(SECOND) != fields[5]
+ || cal.get(MILLISECOND) != fields[6]) {
+ errln("Field " + field
+ + " (" + fieldNames[field]
+ + ") FAIL, expected "
+ + fields[0]
+ + "/" + (fields[1] + 1)
+ + "/" + fields[2]
+ + " " + fields[3]
+ + ":" + fields[4]
+ + ":" + fields[5]
+ + "." + fields[6]
+ + ", got " + cal.get(YEAR)
+ + "/" + (cal.get(MONTH) + 1)
+ + "/" + cal.get(DATE)
+ + " " + cal.get(HOUR_OF_DAY)
+ + ":" + cal.get(MINUTE)
+ + ":" + cal.get(SECOND)
+ + "." + cal.get(MILLISECOND));
cal.clear();
cal.set(fields[0], fields[1], fields[2],
fields[3], fields[4], fields[5]);
- cal.set(Calendar.MILLISECOND, fields[6]);
- errln(cal.get(Calendar.YEAR) +
- "/" + (cal.get(Calendar.MONTH) + 1) +
- "/" + cal.get(Calendar.DATE) +
- " " + cal.get(Calendar.HOUR_OF_DAY) +
- ":" + cal.get(Calendar.MINUTE) +
- ":" + cal.get(Calendar.SECOND) +
- "." + cal.get(Calendar.MILLISECOND));
+ cal.set(MILLISECOND, fields[6]);
+ errln(cal.get(YEAR)
+ + "/" + (cal.get(MONTH) + 1)
+ + "/" + cal.get(DATE)
+ + " " + cal.get(HOUR_OF_DAY)
+ + ":" + cal.get(MINUTE)
+ + ":" + cal.get(SECOND)
+ + "." + cal.get(MILLISECOND));
long prev = cal.getTime().getTime();
- for (int i = 0; i < 2*limit; i++) {
+ for (int i = 0; i < 2 * limit; i++) {
if (op == 0) {
cal.add(field, i < limit ? 1 : -1);
} else {
@@ -1399,25 +1435,24 @@
long t = cal.getTime().getTime();
long delta = t - prev;
prev = t;
- errln((op == 0 ? "add(" : "roll(") +
- fieldNames[field] + ", " +
- (i < limit ? "+" : "-") + "1) => " +
- cal.get(Calendar.YEAR) +
- "/" + (cal.get(Calendar.MONTH) + 1) +
- "/" + cal.get(Calendar.DATE) +
- " " + cal.get(Calendar.HOUR_OF_DAY) +
- ":" + cal.get(Calendar.MINUTE) +
- ":" + cal.get(Calendar.SECOND) +
- "." + cal.get(Calendar.MILLISECOND) +
- " d=" + delta);
+ errln((op == 0 ? "add(" : "roll(")
+ + fieldNames[field] + ", "
+ + (i < limit ? "+" : "-") + "1) => "
+ + cal.get(YEAR)
+ + "/" + (cal.get(MONTH) + 1)
+ + "/" + cal.get(DATE)
+ + " " + cal.get(HOUR_OF_DAY)
+ + ":" + cal.get(MINUTE)
+ + ":" + cal.get(SECOND)
+ + "." + cal.get(MILLISECOND)
+ + " d=" + delta);
}
}
}
}
}
}
- }
- finally {
+ } finally {
Locale.setDefault(savedLocale);
}
}
@@ -1425,14 +1460,14 @@
public void Test4174361() {
GregorianCalendar calendar = new GregorianCalendar(1996, 1, 29);
- calendar.add(Calendar.MONTH, 10);
+ calendar.add(MONTH, 10);
Date date1 = calendar.getTime();
- int d1 = calendar.get(Calendar.DAY_OF_MONTH);
+ int d1 = calendar.get(DAY_OF_MONTH);
calendar = new GregorianCalendar(1996, 1, 29);
- calendar.add(Calendar.MONTH, 11);
+ calendar.add(MONTH, 11);
Date date2 = calendar.getTime();
- int d2 = calendar.get(Calendar.DAY_OF_MONTH);
+ int d2 = calendar.get(DAY_OF_MONTH);
if (d1 != d2) {
errln("adding months to Feb 29 broken");
@@ -1449,9 +1484,9 @@
Calendar cal = Calendar.getInstance(PST, Locale.US);
cal.clear();
cal.set(1999, 3, 21, 15, 5, 0); // Arbitrary
- int h1 = cal.get(Calendar.HOUR_OF_DAY);
+ int h1 = cal.get(HOUR_OF_DAY);
cal.setTimeZone(EST);
- int h2 = cal.get(Calendar.HOUR_OF_DAY);
+ int h2 = cal.get(HOUR_OF_DAY);
if (h1 == h2) {
errln("FAIL: Fields not updated after setTimeZone");
}
@@ -1460,7 +1495,7 @@
// getTime() returns zone-independent time in ms.
cal.clear();
cal.setTimeZone(PST);
- cal.set(Calendar.HOUR_OF_DAY, 10);
+ cal.set(HOUR_OF_DAY, 10);
Date pst10 = cal.getTime();
cal.setTimeZone(EST);
Date est10 = cal.getTime();
@@ -1474,28 +1509,27 @@
*/
public void Test4197699() {
GregorianCalendar cal = new GregorianCalendar();
- cal.setFirstDayOfWeek(Calendar.MONDAY);
+ cal.setFirstDayOfWeek(MONDAY);
cal.setMinimalDaysInFirstWeek(4);
DateFormat fmt = new SimpleDateFormat("E dd MMM yyyy 'DOY='D 'WOY='w");
fmt.setCalendar(cal);
int[] DATA = {
- 2000, Calendar.JANUARY, 1, 52,
- 2001, Calendar.DECEMBER, 31, 1,
- };
+ 2000, JANUARY, 1, 52,
+ 2001, DECEMBER, 31, 1};
- for (int i=0; i<DATA.length; ) {
+ for (int i = 0; i < DATA.length;) {
cal.set(DATA[i++], DATA[i++], DATA[i++]);
int expWOY = DATA[i++];
- int actWOY = cal.get(Calendar.WEEK_OF_YEAR);
+ int actWOY = cal.get(WEEK_OF_YEAR);
if (expWOY == actWOY) {
logln("Ok: " + fmt.format(cal.getTime()));
} else {
errln("FAIL: " + fmt.format(cal.getTime())
- + ", expected WOY=" + expWOY);
- cal.add(Calendar.DATE, -8);
- for (int j=0; j<14; ++j) {
- cal.add(Calendar.DATE, 1);
+ + ", expected WOY=" + expWOY);
+ cal.add(DATE, -8);
+ for (int j = 0; j < 14; ++j) {
+ cal.add(DATE, 1);
logln(fmt.format(cal.getTime()));
}
}
@@ -1514,6 +1548,7 @@
* DAY_OF_YEAR
* WEEK_OF_YEAR + DAY_OF_WEEK
*/
+ @SuppressWarnings("deprecation")
public void Test4209071() {
Calendar cal = Calendar.getInstance(Locale.US);
@@ -1524,106 +1559,104 @@
// Add new test cases as needed.
// 0
- new int[] {}, new Date(Y, Calendar.JANUARY, 1),
+ new int[]{}, new Date(Y, JANUARY, 1),
// 1
- new int[] { Calendar.MONTH, Calendar.MARCH },
- new Date(Y, Calendar.MARCH, 1),
+ new int[]{MONTH, MARCH},
+ new Date(Y, MARCH, 1),
// 2
- new int[] { Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY },
- new Date(Y, Calendar.JANUARY, 4),
+ new int[]{DAY_OF_WEEK, WEDNESDAY},
+ new Date(Y, JANUARY, 4),
// 3
- new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,
- Calendar.DAY_OF_MONTH, 18, },
- new Date(Y, Calendar.JANUARY, 18),
+ new int[]{DAY_OF_WEEK, THURSDAY,
+ DAY_OF_MONTH, 18,},
+ new Date(Y, JANUARY, 18),
// 4
- new int[] { Calendar.DAY_OF_MONTH, 18,
- Calendar.DAY_OF_WEEK, Calendar.THURSDAY, },
- new Date(Y, Calendar.JANUARY, 18),
+ new int[]{DAY_OF_MONTH, 18,
+ DAY_OF_WEEK, THURSDAY,},
+ new Date(Y, JANUARY, 18),
// 5 (WOM -1 is in previous month)
- new int[] { Calendar.DAY_OF_MONTH, 18,
- Calendar.WEEK_OF_MONTH, -1,
- Calendar.DAY_OF_WEEK, Calendar.THURSDAY, },
- new Date(Y-1, Calendar.DECEMBER, 22),
+ new int[]{DAY_OF_MONTH, 18,
+ WEEK_OF_MONTH, -1,
+ DAY_OF_WEEK, THURSDAY,},
+ new Date(Y - 1, DECEMBER, 22),
// 6
- new int[] { Calendar.DAY_OF_MONTH, 18,
- Calendar.WEEK_OF_MONTH, 4,
- Calendar.DAY_OF_WEEK, Calendar.THURSDAY, },
- new Date(Y, Calendar.JANUARY, 26),
+ new int[]{DAY_OF_MONTH, 18,
+ WEEK_OF_MONTH, 4,
+ DAY_OF_WEEK, THURSDAY,},
+ new Date(Y, JANUARY, 26),
// 7 (DIM -1 is in same month)
- new int[] { Calendar.DAY_OF_MONTH, 18,
- Calendar.DAY_OF_WEEK_IN_MONTH, -1,
- Calendar.DAY_OF_WEEK, Calendar.THURSDAY, },
- new Date(Y, Calendar.JANUARY, 26),
+ new int[]{DAY_OF_MONTH, 18,
+ DAY_OF_WEEK_IN_MONTH, -1,
+ DAY_OF_WEEK, THURSDAY,},
+ new Date(Y, JANUARY, 26),
// 8
- new int[] { Calendar.WEEK_OF_YEAR, 9,
- Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY, },
- new Date(Y, Calendar.MARCH, 1),
+ new int[]{WEEK_OF_YEAR, 9,
+ DAY_OF_WEEK, WEDNESDAY,},
+ new Date(Y, MARCH, 1),
// 9
- new int[] { Calendar.MONTH, Calendar.OCTOBER,
- Calendar.DAY_OF_WEEK_IN_MONTH, 1,
- Calendar.DAY_OF_WEEK, Calendar.FRIDAY, },
- new Date(Y, Calendar.OCTOBER, 6),
+ new int[]{MONTH, OCTOBER,
+ DAY_OF_WEEK_IN_MONTH, 1,
+ DAY_OF_WEEK, FRIDAY,},
+ new Date(Y, OCTOBER, 6),
// 10
- new int[] { Calendar.MONTH, Calendar.OCTOBER,
- Calendar.WEEK_OF_MONTH, 2,
- Calendar.DAY_OF_WEEK, Calendar.FRIDAY, },
- new Date(Y, Calendar.OCTOBER, 13),
+ new int[]{MONTH, OCTOBER,
+ WEEK_OF_MONTH, 2,
+ DAY_OF_WEEK, FRIDAY,},
+ new Date(Y, OCTOBER, 13),
// 11
- new int[] { Calendar.MONTH, Calendar.OCTOBER,
- Calendar.DAY_OF_MONTH, 15,
- Calendar.DAY_OF_YEAR, 222, },
- new Date(Y, Calendar.AUGUST, 10),
+ new int[]{MONTH, OCTOBER,
+ DAY_OF_MONTH, 15,
+ DAY_OF_YEAR, 222,},
+ new Date(Y, AUGUST, 10),
// 12
- new int[] { Calendar.DAY_OF_WEEK, Calendar.THURSDAY,
- Calendar.MONTH, Calendar.DECEMBER, },
- new Date(Y, Calendar.DECEMBER, 7),
- };
+ new int[]{DAY_OF_WEEK, THURSDAY,
+ MONTH, DECEMBER,},
+ new Date(Y, DECEMBER, 7)};
- for (int i=0; i<FIELD_DATA.length; i+=2) {
+ for (int i = 0; i < FIELD_DATA.length; i += 2) {
int[] fields = (int[]) FIELD_DATA[i];
- Date exp = (Date) FIELD_DATA[i+1];
+ Date exp = (Date) FIELD_DATA[i + 1];
cal.clear();
- cal.set(Calendar.YEAR, Y + 1900);
- for (int j=0; j<fields.length; j+=2) {
- cal.set(fields[j], fields[j+1]);
+ cal.set(YEAR, Y + 1900);
+ for (int j = 0; j < fields.length; j += 2) {
+ cal.set(fields[j], fields[j + 1]);
}
Date act = cal.getTime();
if (!act.equals(exp)) {
- errln("FAIL: Test " + (i/2) + " got " + act +
- ", want " + exp +
- " (see test/java/util/Calendar/CalendarRegression.java");
+ errln("FAIL: Test " + (i / 2) + " got " + act
+ + ", want " + exp
+ + " (see test/java/util/Calendar/CalendarRegression.java");
}
}
// Test specific failure reported in bug
+ @SuppressWarnings("deprecation")
Object[] DATA = {
- new Integer(1), new Date(1997-1900, Calendar.JANUARY, 5),
- new Integer(4), new Date(1997-1900, Calendar.JANUARY, 26),
- new Integer(8), new Date(1997-1900, Calendar.FEBRUARY, 23),
- new Integer(-1), new Date(1997-1900, Calendar.JANUARY, 26),
- new Integer(-4), new Date(1997-1900, Calendar.JANUARY, 5),
- new Integer(-8), new Date(1996-1900, Calendar.DECEMBER, 8),
- };
- for (int i=0; i<DATA.length; i+=2) {
+ 1, new Date(1997 - 1900, JANUARY, 5),
+ 4, new Date(1997 - 1900, JANUARY, 26),
+ 8, new Date(1997 - 1900, FEBRUARY, 23),
+ -1, new Date(1997 - 1900, JANUARY, 26),
+ -4, new Date(1997 - 1900, JANUARY, 5),
+ -8, new Date(1996 - 1900, DECEMBER, 8)};
+ for (int i = 0; i < DATA.length; i += 2) {
cal.clear();
- cal.set(Calendar.DAY_OF_WEEK_IN_MONTH,
+ cal.set(DAY_OF_WEEK_IN_MONTH,
((Number) DATA[i]).intValue());
- cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
- cal.set(Calendar.MONTH, Calendar.JANUARY);
- cal.set(Calendar.YEAR, 1997);
+ cal.set(DAY_OF_WEEK, SUNDAY);
+ cal.set(MONTH, JANUARY);
+ cal.set(YEAR, 1997);
Date actual = cal.getTime();
- if (!actual.equals(DATA[i+1])) {
- errln("FAIL: Sunday " + DATA[i] +
- " of Jan 1997 -> " + actual +
- ", want " + DATA[i+1]);
+ if (!actual.equals(DATA[i + 1])) {
+ errln("FAIL: Sunday " + DATA[i]
+ + " of Jan 1997 -> " + actual
+ + ", want " + DATA[i + 1]);
}
}
}
- public void Test4288792() throws Exception
- {
+ public void Test4288792() throws Exception {
TimeZone savedTZ = TimeZone.getDefault();
TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
GregorianCalendar cal = new GregorianCalendar();
@@ -1631,45 +1664,44 @@
for (int i = 1900; i < 2100; i++) {
for (int j1 = 1; j1 <= 7; j1++) {
// Loop for MinimalDaysInFirstWeek: 1..7
- for (int j = Calendar.SUNDAY; j <= Calendar.SATURDAY; j++) {
+ for (int j = SUNDAY; j <= SATURDAY; j++) {
// Loop for FirstDayOfWeek: SUNDAY..SATURDAY
cal.clear();
cal.setMinimalDaysInFirstWeek(j1);
cal.setFirstDayOfWeek(j);
- cal.set(Calendar.YEAR, i);
- int maxWeek = cal.getActualMaximum(Calendar.WEEK_OF_YEAR);
- cal.set(Calendar.WEEK_OF_YEAR, maxWeek);
- cal.set(Calendar.DAY_OF_WEEK, j);
+ cal.set(YEAR, i);
+ int maxWeek = cal.getActualMaximum(WEEK_OF_YEAR);
+ cal.set(WEEK_OF_YEAR, maxWeek);
+ cal.set(DAY_OF_WEEK, j);
for (int k = 1; k < 7; k++) {
- cal.add(Calendar.DATE, 1);
- int WOY = cal.get(Calendar.WEEK_OF_YEAR);
+ cal.add(DATE, 1);
+ int WOY = cal.get(WEEK_OF_YEAR);
if (WOY != maxWeek) {
errln(cal.getTime() + ",got=" + WOY
- + ",expected=" + maxWeek
- + ",min=" + j1 + ",first=" + j);
+ + ",expected=" + maxWeek
+ + ",min=" + j1 + ",first=" + j);
}
}
- cal.add(Calendar.DATE, 1);
- int WOY = cal.get(Calendar.WEEK_OF_YEAR);
+ cal.add(DATE, 1);
+ int WOY = cal.get(WEEK_OF_YEAR);
if (WOY != 1) {
errln(cal.getTime() + ",got=" + WOY
- + ",expected=1,min=" + j1 + ",first" + j);
+ + ",expected=1,min=" + j1 + ",first" + j);
}
}
}
}
- }
- finally {
+ } finally {
TimeZone.setDefault(savedTZ);
}
}
public void Test4328747() throws Exception {
- Calendar c = (Calendar)Calendar.getInstance(Locale.US);
+ Calendar c = Calendar.getInstance(Locale.US);
c.clear();
- c.set(1966,0,1); // 1 jan 1966
+ c.set(1966, 0, 1); // 1 jan 1966
// serialize
ByteArrayOutputStream out = new ByteArrayOutputStream();
@@ -1679,16 +1711,16 @@
// deserialize
ObjectInputStream t = new ObjectInputStream(new ByteArrayInputStream(out.toByteArray()));
- Calendar result = (Calendar)t.readObject();
+ Calendar result = (Calendar) t.readObject();
// let recalculate fields with the same UTC time
result.setTime(result.getTime());
// Bug gives 1965 11 19
- if ((result.get(c.YEAR) != 1966) || (result.get(c.MONTH) != 0)
- || (result.get(c.DATE) != 1)) {
+ if ((result.get(YEAR) != 1966) || (result.get(MONTH) != 0)
+ || (result.get(DATE) != 1)) {
errln("deserialized Calendar returned wrong date field(s): "
- + result.get(c.YEAR) + "/" + result.get(c.MONTH) + "/" + result.get(c.DATE)
- + ", expected 1966/0/1");
+ + result.get(YEAR) + "/" + result.get(MONTH) + "/" + result.get(DATE)
+ + ", expected 1966/0/1");
}
}
@@ -1700,13 +1732,13 @@
TimeZone savedTimeZone = TimeZone.getDefault();
try {
boolean pass = true;
- String[] IDs = new String[] {"Undefined", "PST", "US/Pacific",
- "GMT+3:00", "GMT-01:30"};
+ String[] IDs = new String[]{"Undefined", "PST", "US/Pacific",
+ "GMT+3:00", "GMT-01:30"};
for (int i = 0; i < IDs.length; i++) {
TimeZone tz = TimeZone.getTimeZone(IDs[i]);
TimeZone.setDefault(tz);
- Calendar c = (Calendar)Calendar.getInstance();
+ Calendar c = Calendar.getInstance();
// serialize
ByteArrayOutputStream out = new ByteArrayOutputStream();
@@ -1719,26 +1751,20 @@
if (!c.equals(t.readObject())) {
pass = false;
- logln("Calendar instance which uses TimeZone <" +
- IDs[i] + "> is incorrectly serialized/deserialized.");
+ logln("Calendar instance which uses TimeZone <"
+ + IDs[i] + "> is incorrectly serialized/deserialized.");
} else {
- logln("Calendar instance which uses TimeZone <" +
- IDs[i] + "> is correctly serialized/deserialized.");
+ logln("Calendar instance which uses TimeZone <"
+ + IDs[i] + "> is correctly serialized/deserialized.");
}
}
if (!pass) {
errln("Fail: Calendar serialization/equality bug");
}
- }
- catch (IOException e) {
+ } catch (IOException | ClassNotFoundException e) {
errln("Fail: " + e);
e.printStackTrace();
- }
- catch (ClassNotFoundException e) {
- errln("Fail: " + e);
- e.printStackTrace();
- }
- finally {
+ } finally {
TimeZone.setDefault(savedTimeZone);
}
}
@@ -1747,12 +1773,12 @@
* 4546637: Incorrect WEEK_OF_MONTH after changing First Day Of Week
*/
public void Test4546637() {
- GregorianCalendar day = new GregorianCalendar (2001, Calendar.NOVEMBER, 04);
+ GregorianCalendar day = new GregorianCalendar(2001, NOVEMBER, 04);
day.setMinimalDaysInFirstWeek(1);
- int wom = day.get(Calendar.WEEK_OF_MONTH);
+ int wom = day.get(WEEK_OF_MONTH);
- day.setFirstDayOfWeek(Calendar.MONDAY);
- if (day.get(Calendar.WEEK_OF_MONTH) != 1) {
+ day.setFirstDayOfWeek(MONDAY);
+ if (day.get(WEEK_OF_MONTH) != 1) {
errln("Fail: 2001/11/4 must be the first week of the month.");
}
}
@@ -1761,14 +1787,14 @@
* 4623997: GregorianCalendar returns bad WEEK_OF_YEAR
*/
public void Test4623997() {
- GregorianCalendar cal = new GregorianCalendar(2000, GregorianCalendar.JANUARY, 1);
+ GregorianCalendar cal = new GregorianCalendar(2000, JANUARY, 1);
- int dow = cal.get(GregorianCalendar.DAY_OF_WEEK);
+ int dow = cal.get(DAY_OF_WEEK);
- cal.setFirstDayOfWeek(GregorianCalendar.MONDAY);
+ cal.setFirstDayOfWeek(MONDAY);
cal.setMinimalDaysInFirstWeek(4);
- if (cal.get(GregorianCalendar.WEEK_OF_YEAR) != 52) {
+ if (cal.get(WEEK_OF_YEAR) != 52) {
errln("Fail: 2000/1/1 must be the 52nd week of the year.");
}
}
@@ -1800,9 +1826,9 @@
}
t = calendar.getTime();
- calendar.set(Calendar.DAY_OF_MONTH, 33);
+ calendar.set(DAY_OF_MONTH, 33);
t = calendar.getTime();
- calendar.set(Calendar.DAY_OF_MONTH, 0);
+ calendar.set(DAY_OF_MONTH, 0);
s = df.format(calendar.getTime());
if (!expected.equals(s)) {
errln("DAY_OF_MONTH w/o ZONE_OFFSET: expected: " + expected + ", got: " + s);
@@ -1815,10 +1841,10 @@
throw new RuntimeException("Unexpected parse exception", e);
}
t = calendar.getTime();
- calendar.set(calendar.ZONE_OFFSET, calendar.get(calendar.ZONE_OFFSET));
- calendar.set(Calendar.DAY_OF_MONTH, 33);
+ calendar.set(ZONE_OFFSET, calendar.get(ZONE_OFFSET));
+ calendar.set(DAY_OF_MONTH, 33);
t = calendar.getTime();
- calendar.set(Calendar.DAY_OF_MONTH, 0);
+ calendar.set(DAY_OF_MONTH, 0);
s = df.format(calendar.getTime());
if (!expected.equals(s)) {
errln("DAY_OF_MONTH: expected: " + expected + ", got: " + s);
@@ -1834,11 +1860,11 @@
throw new RuntimeException("Unexpected parse exception", e);
}
t = calendar.getTime();
- calendar.set(calendar.ZONE_OFFSET, calendar.get(calendar.ZONE_OFFSET));
+ calendar.set(ZONE_OFFSET, calendar.get(ZONE_OFFSET));
// jump to the next year
- calendar.set(Calendar.WEEK_OF_YEAR, 100);
+ calendar.set(WEEK_OF_YEAR, 100);
t = calendar.getTime();
- calendar.set(Calendar.WEEK_OF_YEAR, 0);
+ calendar.set(WEEK_OF_YEAR, 0);
s = df.format(calendar.getTime());
if (!expected.equals(s)) {
errln("WEEK_OF_YEAR: expected: " + expected + ", got: " + s);
@@ -1846,11 +1872,11 @@
// change the state back
calendar.clear();
calendar.setTime(initialDate);
- calendar.set(calendar.ZONE_OFFSET, calendar.get(calendar.ZONE_OFFSET));
+ calendar.set(ZONE_OFFSET, calendar.get(ZONE_OFFSET));
// jump to next month
- calendar.set(Calendar.WEEK_OF_MONTH, 7);
+ calendar.set(WEEK_OF_MONTH, 7);
t = calendar.getTime();
- calendar.set(Calendar.WEEK_OF_MONTH, 0);
+ calendar.set(WEEK_OF_MONTH, 0);
s = df.format(calendar.getTime());
if (!expected.equals(s)) {
errln("WEEK_OF_MONTH: expected: " + expected + ", got: " + s);
@@ -1870,10 +1896,10 @@
}
t = calendar.getTime();
// time should be 22:59:59.
- calendar.set(Calendar.MINUTE, 61);
+ calendar.set(MINUTE, 61);
// time should be 23:01:59.
t = calendar.getTime();
- calendar.set(Calendar.MINUTE, -1);
+ calendar.set(MINUTE, -1);
// time should be back to 22:59:59.
s = df.format(calendar.getTime());
if (!expected.equals(s)) {
@@ -1896,15 +1922,15 @@
Calendar cal = Calendar.getInstance();
cal.setTime(new Date(1029814211523L));
- cal.set(Calendar.YEAR, 2001);
+ cal.set(YEAR, 2001);
Date t = cal.getTime();
- cal.set(Calendar.MONTH, Calendar.JANUARY);
+ cal.set(MONTH, JANUARY);
t = cal.getTime();
- cal.set(Calendar.DAY_OF_MONTH, 8);
+ cal.set(DAY_OF_MONTH, 8);
t = cal.getTime();
- cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
+ cal.set(DAY_OF_WEEK, MONDAY);
DateFormat df = new SimpleDateFormat("yyyy/MM/dd", Locale.US);
String expected = "2001/01/08";
String s = df.format(cal.getTime());
@@ -1923,9 +1949,9 @@
*/
public void Test4683492() {
Calendar cal = new GregorianCalendar(2002, 3, 29, 10, 0, 0);
- cal.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
- cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, -1);
- cal.set(Calendar.MONTH, 12);
+ cal.set(DAY_OF_WEEK, FRIDAY);
+ cal.set(DAY_OF_WEEK_IN_MONTH, -1);
+ cal.set(MONTH, 12);
DateFormat df = new SimpleDateFormat("yyyy/MM/dd", Locale.US);
String expected = "2003/01/31";
String s = df.format(cal.getTime());
@@ -1940,31 +1966,31 @@
public void Test4080631() {
Calendar cal = Calendar.getInstance();
int h1 = cal.hashCode();
- cal.add(cal.SECOND, +1);
+ cal.add(SECOND, +1);
int h2 = cal.hashCode();
Calendar cal2 = (Calendar) cal.clone();
- cal.add(cal.MILLISECOND, +1);
+ cal.add(MILLISECOND, +1);
int h3 = cal.hashCode();
- logln("hash code: h1="+h1+", h2="+h2+", h3="+h3);
+ logln("hash code: h1=" + h1 + ", h2=" + h2 + ", h3=" + h3);
if (h1 == h2 || h1 == h3 || h2 == h3) {
- errln("hash code is poor: hashCode="+h1);
+ errln("hash code is poor: hashCode=" + h1);
}
h2 = cal2.hashCode();
- cal.add(cal.MILLISECOND, -1);
+ cal.add(MILLISECOND, -1);
int h4 = cal.hashCode();
- logln("hash code: h2="+h2+", h4="+h4);
+ logln("hash code: h2=" + h2 + ", h4=" + h4);
if (cal.equals(cal2) && h2 != h4) {
- errln("broken hash code: h2="+h2+", h4="+h4);
+ errln("broken hash code: h2=" + h2 + ", h4=" + h4);
}
int x = cal.getFirstDayOfWeek() + 3;
- if (x > cal.SATURDAY) {
+ if (x > SATURDAY) {
x -= 7;
}
cal.setFirstDayOfWeek(x);
int h5 = cal.hashCode();
- logln("hash code: h4="+h4+", h5="+h5);
+ logln("hash code: h4=" + h4 + ", h5=" + h5);
if (h4 == h5) {
- errln("has code is poor with first day of week param: hashCode="+h4);
+ errln("has code is poor with first day of week param: hashCode=" + h4);
}
}
@@ -1991,8 +2017,7 @@
errln("Wrong BCE and/or CE values");
}
}
- */
-
+ */
/**
* 4167995: GregorianCalendar.setGregorianChange() not to spec
*/
@@ -2000,42 +2025,42 @@
Koyomi gc = new Koyomi(TimeZone.getTimeZone("GMT"));
logln("Hybrid: min date");
gc.setTime(new Date(Long.MIN_VALUE));
- if (!gc.checkDate(292269055, gc.DECEMBER, 2, gc.SUNDAY)
- || !gc.checkFieldValue(gc.ERA, gc.BC)) {
+ if (!gc.checkDate(292269055, DECEMBER, 2, SUNDAY)
+ || !gc.checkFieldValue(ERA, GregorianCalendar.BC)) {
errln(gc.getMessage());
}
logln("Hybrid: max date");
gc.setTime(new Date(Long.MAX_VALUE));
- if (!gc.checkDate(292278994, gc.AUGUST, 17, gc.SUNDAY)
- || !gc.checkFieldValue(gc.ERA, gc.AD)) {
+ if (!gc.checkDate(292278994, AUGUST, 17, SUNDAY)
+ || !gc.checkFieldValue(ERA, GregorianCalendar.AD)) {
errln(gc.getMessage());
}
gc.setGregorianChange(new Date(Long.MIN_VALUE));
logln("Gregorian: min date");
gc.setTime(new Date(Long.MIN_VALUE));
- if (!gc.checkDate(292275056, gc.MAY, 16, gc.SUNDAY)
- || !gc.checkFieldValue(gc.ERA, gc.BC)) {
+ if (!gc.checkDate(292275056, MAY, 16, SUNDAY)
+ || !gc.checkFieldValue(ERA, GregorianCalendar.BC)) {
errln(gc.getMessage());
}
logln("Gregorian: max date");
gc.setTime(new Date(Long.MAX_VALUE));
- if (!gc.checkDate(292278994, gc.AUGUST, 17, gc.SUNDAY)
- || !gc.checkFieldValue(gc.ERA, gc.AD)) {
+ if (!gc.checkDate(292278994, AUGUST, 17, SUNDAY)
+ || !gc.checkFieldValue(ERA, GregorianCalendar.AD)) {
errln(gc.getMessage());
}
gc.setGregorianChange(new Date(Long.MAX_VALUE));
logln("Julian: min date");
gc.setTime(new Date(Long.MIN_VALUE));
- if (!gc.checkDate(292269055, gc.DECEMBER, 2, gc.SUNDAY)
- || !gc.checkFieldValue(gc.ERA, gc.BC)) {
+ if (!gc.checkDate(292269055, DECEMBER, 2, SUNDAY)
+ || !gc.checkFieldValue(ERA, GregorianCalendar.BC)) {
errln(gc.getMessage());
}
logln("Julian: max date");
gc.setTime(new Date(Long.MAX_VALUE));
- if (!gc.checkDate(292272993, gc.JANUARY, 4, gc.SUNDAY)
- || !gc.checkFieldValue(gc.ERA, gc.AD)) {
+ if (!gc.checkDate(292272993, JANUARY, 4, SUNDAY)
+ || !gc.checkFieldValue(ERA, GregorianCalendar.AD)) {
errln(gc.getMessage());
}
}
@@ -2046,13 +2071,13 @@
public void Test4340146() {
Koyomi cal = new Koyomi();
cal.clear();
- cal.set(2003, cal.OCTOBER, 32);
+ cal.set(2003, OCTOBER, 32);
cal.equals(new Koyomi());
- if (!cal.checkInternalDate(2003, cal.OCTOBER, 32)) {
+ if (!cal.checkInternalDate(2003, OCTOBER, 32)) {
errln(cal.getMessage());
}
new Koyomi().equals(cal);
- if (!cal.checkInternalDate(2003, cal.OCTOBER, 32)) {
+ if (!cal.checkInternalDate(2003, OCTOBER, 32)) {
errln(cal.getMessage());
}
}
@@ -2065,10 +2090,10 @@
// throw IllegalArgumentException.
Koyomi cal = new Koyomi(TimeZone.getTimeZone("Pacific/Kiritimati"));
cal.setLenient(false);
- cal.set(2003, cal.OCTOBER, 10);
+ cal.set(2003, OCTOBER, 10);
cal.getTime();
cal.setTimeZone(TimeZone.getTimeZone("Pacific/Tongatapu"));
- cal.set(2003, cal.OCTOBER, 10);
+ cal.set(2003, OCTOBER, 10);
cal.getTime();
}
@@ -2077,10 +2102,10 @@
*/
public void Test4652815() {
Koyomi cal = new Koyomi(Locale.US);
- testRoll(cal, 2003, cal.SEPTEMBER, 29);
- testRoll(cal, 2003, cal.DECEMBER, 24);
- testRoll(cal, 1582, cal.DECEMBER, 19);
- testRoll(cal, 1582, cal.DECEMBER, 20);
+ testRoll(cal, 2003, SEPTEMBER, 29);
+ testRoll(cal, 2003, DECEMBER, 24);
+ testRoll(cal, 1582, DECEMBER, 19);
+ testRoll(cal, 1582, DECEMBER, 20);
}
private void testRoll(Koyomi cal, int year, int month, int dayOfMonth) {
@@ -2089,15 +2114,15 @@
cal.getTime(); // normalize fields
logln("Roll backwards from " + cal.toDateString());
for (int i = 0; i < 1000; i++) {
- cal.roll(cal.WEEK_OF_YEAR, -i);
- if (!cal.checkFieldValue(cal.YEAR, year)) {
+ cal.roll(WEEK_OF_YEAR, -i);
+ if (!cal.checkFieldValue(YEAR, year)) {
errln(cal.getMessage());
}
}
logln("Roll forewards from " + cal.toDateString());
for (int i = 0; i < 1000; i++) {
- cal.roll(cal.WEEK_OF_YEAR, +i);
- if (!cal.checkFieldValue(cal.YEAR, year)) {
+ cal.roll(WEEK_OF_YEAR, +i);
+ if (!cal.checkFieldValue(YEAR, year)) {
errln(cal.getMessage());
}
}
@@ -2110,20 +2135,20 @@
Koyomi cal = new Koyomi(Locale.US);
cal.clear();
logln("BCE 9-2-28 (leap year) roll DAY_OF_MONTH++ twice");
- cal.set(cal.ERA, cal.BC);
- cal.set(9, cal.FEBRUARY, 28);
- if (cal.getActualMaximum(cal.DAY_OF_YEAR) != 366) {
+ cal.set(ERA, GregorianCalendar.BC);
+ cal.set(9, FEBRUARY, 28);
+ if (cal.getActualMaximum(DAY_OF_YEAR) != 366) {
errln(" wrong actual max of DAY_OF_YEAR: got "
- + cal.getActualMaximum(cal.DAY_OF_YEAR) + " expected " + 366);
+ + cal.getActualMaximum(DAY_OF_YEAR) + " expected " + 366);
}
- cal.roll(cal.DAY_OF_MONTH, +1);
- if (!cal.checkFieldValue(cal.ERA, cal.BC)
- || !cal.checkDate(9, cal.FEBRUARY, 29)) {
+ cal.roll(DAY_OF_MONTH, +1);
+ if (!cal.checkFieldValue(ERA, GregorianCalendar.BC)
+ || !cal.checkDate(9, FEBRUARY, 29)) {
errln(cal.getMessage());
}
- cal.roll(cal.DAY_OF_MONTH, +1);
- if (!cal.checkFieldValue(cal.ERA, cal.BC)
- || !cal.checkDate(9, cal.FEBRUARY, 1)) {
+ cal.roll(DAY_OF_MONTH, +1);
+ if (!cal.checkFieldValue(ERA, GregorianCalendar.BC)
+ || !cal.checkDate(9, FEBRUARY, 1)) {
errln(cal.getMessage());
}
}
@@ -2135,11 +2160,11 @@
logln("1999/(Feb+12)/1 should be normalized to 2000/Feb/1 for getActualMaximum");
Koyomi cal = new Koyomi(Locale.US);
cal.clear();
- cal.set(1999, cal.FEBRUARY + 12, 1);
- if (!cal.checkActualMaximum(cal.DAY_OF_YEAR, 366)) {
+ cal.set(1999, FEBRUARY + 12, 1);
+ if (!cal.checkActualMaximum(DAY_OF_YEAR, 366)) {
errln(cal.getMessage());
}
- if (!cal.checkActualMaximum(cal.DAY_OF_MONTH, 29)) {
+ if (!cal.checkActualMaximum(DAY_OF_MONTH, 29)) {
errln(cal.getMessage());
}
}
@@ -2150,36 +2175,36 @@
public void Test4936355() {
Koyomi cal = new Koyomi(TimeZone.getTimeZone("GMT"));
cal.clear();
- cal.set(1970, cal.JANUARY, 1);
- checkTimeCalculation(cal, cal.HOUR_OF_DAY, Integer.MAX_VALUE,
- (long)Integer.MAX_VALUE * 60 * 60 * 1000);
+ cal.set(1970, JANUARY, 1);
+ checkTimeCalculation(cal, HOUR_OF_DAY, Integer.MAX_VALUE,
+ (long) Integer.MAX_VALUE * 60 * 60 * 1000);
cal.clear();
- cal.set(1970, cal.JANUARY, 1);
- checkTimeCalculation(cal, cal.HOUR, Integer.MAX_VALUE,
- (long)Integer.MAX_VALUE * 60 * 60 * 1000);
+ cal.set(1970, JANUARY, 1);
+ checkTimeCalculation(cal, HOUR, Integer.MAX_VALUE,
+ (long) Integer.MAX_VALUE * 60 * 60 * 1000);
cal.clear();
- cal.set(1970, cal.JANUARY, 1);
- checkTimeCalculation(cal, cal.MINUTE, Integer.MAX_VALUE,
- (long)Integer.MAX_VALUE * 60 * 1000);
+ cal.set(1970, JANUARY, 1);
+ checkTimeCalculation(cal, MINUTE, Integer.MAX_VALUE,
+ (long) Integer.MAX_VALUE * 60 * 1000);
cal.clear();
// Make sure to use Gregorian dates (before and after the
// set() call) for testing
- cal.set(250000, cal.JANUARY, 1);
- checkTimeCalculation(cal, cal.HOUR_OF_DAY, Integer.MIN_VALUE,
- (long)Integer.MIN_VALUE * 60 * 60 * 1000);
+ cal.set(250000, JANUARY, 1);
+ checkTimeCalculation(cal, HOUR_OF_DAY, Integer.MIN_VALUE,
+ (long) Integer.MIN_VALUE * 60 * 60 * 1000);
cal.clear();
- cal.set(250000, cal.JANUARY, 1);
- checkTimeCalculation(cal, cal.HOUR, Integer.MIN_VALUE,
- (long)Integer.MIN_VALUE * 60 * 60 * 1000);
+ cal.set(250000, JANUARY, 1);
+ checkTimeCalculation(cal, HOUR, Integer.MIN_VALUE,
+ (long) Integer.MIN_VALUE * 60 * 60 * 1000);
cal.clear();
- cal.set(250000, cal.JANUARY, 1);
- checkTimeCalculation(cal, cal.MINUTE, Integer.MIN_VALUE,
- (long)Integer.MIN_VALUE * 60 * 1000);
+ cal.set(250000, JANUARY, 1);
+ checkTimeCalculation(cal, MINUTE, Integer.MIN_VALUE,
+ (long) Integer.MIN_VALUE * 60 * 1000);
}
private void checkTimeCalculation(Koyomi cal, int field, int value, long expectedDelta) {
@@ -2189,7 +2214,7 @@
if ((time + expectedDelta) != time2) {
String s = value == Integer.MAX_VALUE ? "Integer.MAX_VALUE" : "Integer.MIN_VALUE";
errln("set(" + Koyomi.getFieldName(field) + ", " + s + ") failed." + " got " + time2
- + ", expected " + (time+expectedDelta));
+ + ", expected " + (time + expectedDelta));
}
}
@@ -2204,8 +2229,8 @@
cal2.clear();
cal2.setLenient(false);
- cal1.set(2003, Calendar.OCTOBER, 31);
- cal2.set(2003, Calendar.OCTOBER, 31);
+ cal1.set(2003, OCTOBER, 31);
+ cal2.set(2003, OCTOBER, 31);
try {
if (cal1.equals(cal2)) {
errln("lenient and non-lenient shouldn't be equal. (2003/10/31)");
@@ -2217,8 +2242,8 @@
errln("equals threw IllegalArugumentException with non-lenient");
}
- cal1.set(2003, Calendar.OCTOBER, 32);
- cal2.set(2003, Calendar.OCTOBER, 32);
+ cal1.set(2003, OCTOBER, 32);
+ cal2.set(2003, OCTOBER, 32);
try {
if (cal1.equals(cal2)) {
errln("lenient and non-lenient shouldn't be equal. (2003/10/32)");
@@ -2246,17 +2271,17 @@
* 4738710: API: Calendar comparison methods should be improved
*/
public void Test4738710() {
- Calendar cal0 = new GregorianCalendar(2003, Calendar.SEPTEMBER, 30);
- Comparable<Calendar> cal1 = new GregorianCalendar(2003, Calendar.OCTOBER, 1);
- Calendar cal2 = new GregorianCalendar(2003, Calendar.OCTOBER, 2);
+ Calendar cal0 = new GregorianCalendar(2003, SEPTEMBER, 30);
+ Comparable<Calendar> cal1 = new GregorianCalendar(2003, OCTOBER, 1);
+ Calendar cal2 = new GregorianCalendar(2003, OCTOBER, 2);
if (!(cal1.compareTo(cal0) > 0)) {
errln("!(cal1 > cal0)");
}
if (!(cal1.compareTo(cal2) < 0)) {
errln("!(cal1 < cal2)");
}
- if (cal1.compareTo(new GregorianCalendar(2003, Calendar.OCTOBER, 1)) != 0) {
- errln("cal1 != new GregorianCalendar(2003, Calendar.OCTOBER, 1)");
+ if (cal1.compareTo(new GregorianCalendar(2003, OCTOBER, 1)) != 0) {
+ errln("cal1 != new GregorianCalendar(2003, OCTOBER, 1)");
}
if (cal0.after(cal2)) {
@@ -2266,10 +2291,10 @@
errln("cal2 shouldn't be before cal0");
}
- if (cal0.after(new Integer(0))) {
+ if (cal0.after(0)) {
errln("cal0.after() returned true with an Integer.");
}
- if (cal0.before(new Integer(0))) {
+ if (cal0.before(0)) {
errln("cal0.before() returned true with an Integer.");
}
if (cal0.after(null)) {
@@ -2283,34 +2308,35 @@
/**
* 4633646: Setting WEEK_OF_MONTH to 1 results in incorrect date
*/
+ @SuppressWarnings("deprecation")
public void Test4633646() {
Koyomi cal = new Koyomi(Locale.US);
- cal.setTime(new Date(2002-1900, 1-1, 28));
+ cal.setTime(new Date(2002 - 1900, 1 - 1, 28));
sub4633646(cal);
cal.setLenient(false);
- cal.setTime(new Date(2002-1900, 1-1, 28));
+ cal.setTime(new Date(2002 - 1900, 1 - 1, 28));
sub4633646(cal);
cal = new Koyomi(Locale.US);
cal.clear();
- cal.set(2002, cal.JANUARY, 28);
+ cal.set(2002, JANUARY, 28);
sub4633646(cal);
cal.clear();
cal.setLenient(false);
- cal.set(2002, cal.JANUARY, 28);
+ cal.set(2002, JANUARY, 28);
sub4633646(cal);
}
void sub4633646(Koyomi cal) {
cal.getTime();
- cal.set(cal.WEEK_OF_MONTH, 1);
+ cal.set(WEEK_OF_MONTH, 1);
if (cal.isLenient()) {
- if (!cal.checkDate(2001, cal.DECEMBER, 31)) {
+ if (!cal.checkDate(2001, DECEMBER, 31)) {
errln(cal.getMessage());
}
- if (!cal.checkFieldValue(cal.WEEK_OF_MONTH, 6)) {
+ if (!cal.checkFieldValue(WEEK_OF_MONTH, 6)) {
errln(cal.getMessage());
}
} else {
@@ -2329,29 +2355,29 @@
public void Test4846659() {
Koyomi cal = new Koyomi();
cal.clear();
- cal.set(2003, cal.OCTOBER, 31, 10, 30, 30);
+ cal.set(2003, OCTOBER, 31, 10, 30, 30);
cal.getTime();
// Test roll()
- cal.roll(cal.AM_PM, +1); // should turn to PM
- if (!cal.checkFieldValue(cal.HOUR_OF_DAY, 10+12)) {
+ cal.roll(AM_PM, +1); // should turn to PM
+ if (!cal.checkFieldValue(HOUR_OF_DAY, 10 + 12)) {
errln("roll: AM_PM didn't change to PM");
}
cal.clear();
- cal.set(2003, cal.OCTOBER, 31, 10, 30, 30);
+ cal.set(2003, OCTOBER, 31, 10, 30, 30);
cal.getTime();
// Test set()
- cal.set(cal.AM_PM, cal.PM); // should turn to PM
- if (!cal.checkFieldValue(cal.HOUR_OF_DAY, 10+12)) {
+ cal.set(AM_PM, PM); // should turn to PM
+ if (!cal.checkFieldValue(HOUR_OF_DAY, 10 + 12)) {
errln("set: AM_PM didn't change to PM");
}
cal.clear();
- cal.set(2003, cal.OCTOBER, 31, 10, 30, 30);
+ cal.set(2003, OCTOBER, 31, 10, 30, 30);
cal.getTime();
- cal.set(cal.AM_PM, cal.PM);
- cal.set(cal.HOUR, 9);
- if (!cal.checkFieldValue(cal.HOUR_OF_DAY, 9+12)) {
+ cal.set(AM_PM, PM);
+ cal.set(HOUR, 9);
+ if (!cal.checkFieldValue(HOUR_OF_DAY, 9 + 12)) {
errln("set: both AM_PM and HOUT didn't change to PM");
}
}
@@ -2370,15 +2396,15 @@
// 29 30
cal.clear();
// 6/1 to 6/7 should be the 1st week of June.
- cal.set(2003, cal.JUNE, 2);
+ cal.set(2003, JUNE, 2);
cal.getTime(); // Let cal calculate time.
- cal.setFirstDayOfWeek(cal.MONDAY);
+ cal.setFirstDayOfWeek(MONDAY);
// Now 6/2 to 6/8 should be the 2nd week of June. Sunday of
// that week is 6/8.
- logln("1: " +cal.get(cal.WEEK_OF_MONTH)+", "+cal.get(cal.DAY_OF_MONTH));
- cal.set(cal.DAY_OF_WEEK, cal.SUNDAY);
+ logln("1: " + cal.get(WEEK_OF_MONTH) + ", " + cal.get(DAY_OF_MONTH));
+ cal.set(DAY_OF_WEEK, SUNDAY);
logln("1st Sunday of June 2003 with FirstDayOfWeek=MONDAY");
- if (!cal.checkDate(2003, cal.JUNE, 8)) {
+ if (!cal.checkDate(2003, JUNE, 8)) {
errln(cal.getMessage());
}
}
@@ -2387,7 +2413,7 @@
* 4973919: Inconsistent GregorianCalendar hashCode before and after serialization
*/
public void Test4966499() throws Exception {
- GregorianCalendar date1 = new GregorianCalendar(2004, Calendar.JANUARY, 7);
+ GregorianCalendar date1 = new GregorianCalendar(2004, JANUARY, 7);
// Serialize date1
ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -2399,15 +2425,15 @@
// Deserialize it
ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
ObjectInputStream ois = new ObjectInputStream(bais);
- GregorianCalendar date2 = (GregorianCalendar)ois.readObject();
+ GregorianCalendar date2 = (GregorianCalendar) ois.readObject();
if (!date1.equals(date2)) {
errln("date1.equals(date2) != true");
}
if (date1.hashCode() != date2.hashCode()) {
errln("inconsistent hashCode() value (before=0x"
- +Integer.toHexString(date1.hashCode())+
- ", after=0x"+Integer.toHexString(date2.hashCode())+")");
+ + Integer.toHexString(date1.hashCode())
+ + ", after=0x" + Integer.toHexString(date2.hashCode()) + ")");
}
}
@@ -2468,29 +2494,26 @@
TimeZone savedZone = TimeZone.getDefault();
TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
try {
- Map<Date, Boolean> data = new HashMap<Date, Boolean>();
- data.put(getGregorianDate(999, Calendar.OCTOBER, 1), Boolean.FALSE);
- data.put(getGregorianDate(1000, Calendar.JANUARY, 1), Boolean.FALSE);
- data.put(getGregorianDate(1000, Calendar.FEBRUARY, 1), Boolean.FALSE);
- data.put(getGregorianDate(1000, Calendar.FEBRUARY, 28), Boolean.FALSE);
- data.put(getGregorianDate(1000, Calendar.MARCH, 1), Boolean.TRUE);
- data.put(getGregorianDate(1001, Calendar.JANUARY, 1), Boolean.TRUE);
- data.put(getGregorianDate(1001, Calendar.JANUARY, 6), Boolean.TRUE);
- data.put(getGregorianDate(1001, Calendar.MARCH, 1), Boolean.TRUE);
+ Map<Date, Boolean> data = new HashMap<>();
+ data.put(getGregorianDate(999, OCTOBER, 1), Boolean.FALSE);
+ data.put(getGregorianDate(1000, JANUARY, 1), Boolean.FALSE);
+ data.put(getGregorianDate(1000, FEBRUARY, 1), Boolean.FALSE);
+ data.put(getGregorianDate(1000, FEBRUARY, 28), Boolean.FALSE);
+ data.put(getGregorianDate(1000, MARCH, 1), Boolean.TRUE);
+ data.put(getGregorianDate(1001, JANUARY, 1), Boolean.TRUE);
+ data.put(getGregorianDate(1001, JANUARY, 6), Boolean.TRUE);
+ data.put(getGregorianDate(1001, MARCH, 1), Boolean.TRUE);
- Iterator<Date> itr = data.keySet().iterator();
- while (itr.hasNext()) {
- Date d = itr.next();
- boolean expected = data.get(d).booleanValue();
+ data.keySet().forEach(d -> {
+ boolean expected = data.get(d);
GregorianCalendar cal = new GregorianCalendar();
cal.setGregorianChange(d);
if (cal.isLeapYear(1000) != expected) {
- errln("isLeapYear(1000) returned " + cal.isLeapYear(1000) +
- " with cutover date (Julian) " + d);
+ errln("isLeapYear(1000) returned " + cal.isLeapYear(1000)
+ + " with cutover date (Julian) " + d);
}
- }
- }
- finally {
+ });
+ } finally {
TimeZone.setDefault(savedZone);
}
}
@@ -2511,15 +2534,15 @@
*/
public void Test5006864() {
GregorianCalendar cal = new GregorianCalendar();
- int min = cal.getMinimum(cal.DAY_OF_WEEK_IN_MONTH);
+ int min = cal.getMinimum(DAY_OF_WEEK_IN_MONTH);
if (min != 1) {
errln("GregorianCalendar.getMinimum(DAY_OF_WEEK_IN_MONTH) returned "
- + min + ", expected 1.");
+ + min + ", expected 1.");
}
- min = cal.getGreatestMinimum(cal.DAY_OF_WEEK_IN_MONTH);
+ min = cal.getGreatestMinimum(DAY_OF_WEEK_IN_MONTH);
if (min != 1) {
errln("GregorianCalendar.getGreatestMinimum(DAY_OF_WEEK_IN_MONTH) returned "
- + min + ", expected 1.");
+ + min + ", expected 1.");
}
}
}
--- a/jdk/test/java/util/Calendar/CalendarTest.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/CalendarTest.java Thu Nov 17 11:40:50 2016 +0530
@@ -30,12 +30,25 @@
* @key randomness
*/
-import java.util.*;
-import java.text.*;
-import java.io.*;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutput;
+import java.io.ObjectOutputStream;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.SimpleTimeZone;
+import java.util.TimeZone;
+
+import static java.util.Calendar.*;
public class CalendarTest extends IntlTest {
- static final int ONE_DAY = 24*60*60*1000;
+
+ static final int ONE_DAY = 24 * 60 * 60 * 1000;
static final int EPOCH_JULIAN = 2440588;
public static void main(String argv[]) throws Exception {
@@ -64,32 +77,31 @@
Changeover +6 days: 1582/10/21 dow=5
Changeover +7 days: 1582/10/22 dow=6
*/
- int MON[] = { 9, 9, 9,10,10,10,10, 10, 10, 10, 10, 10, 10, 10, 10 };
- int DOM[] = { 28, 29, 30, 1, 2, 3, 4, 15, 16, 17, 18, 19, 20, 21, 22 };
- int DOW[] = { 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6 };
+ int[] MON = { 9, 9, 9,10,10,10,10, 10, 10, 10, 10, 10, 10, 10, 10 };
+ int[] DOM = { 28, 29, 30, 1, 2, 3, 4, 15, 16, 17, 18, 19, 20, 21, 22 };
+ int[] DOW = { 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6 };
// ^ <-Changeover Fri Oct 15 1582
-
try {
TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
- Date co = new Date(1582-1900, Calendar.OCTOBER, 15);
+ @SuppressWarnings("deprecation")
+ Date co = new Date(1582 - 1900, OCTOBER, 15);
GregorianCalendar cal = new GregorianCalendar();
int j = 0;
for (int i = -7; i <= 7; ++i, ++j) {
- Date d = new Date(co.getTime() + i*ONE_DAY);
+ Date d = new Date(co.getTime() + i * ONE_DAY);
cal.setTime(d);
- int y = cal.get(Calendar.YEAR);
- int mon = cal.get(Calendar.MONTH)+1-Calendar.JANUARY;
- int dom = cal.get(Calendar.DATE);
- int dow = cal.get(Calendar.DAY_OF_WEEK);
+ int y = cal.get(YEAR);
+ int mon = cal.get(MONTH) + 1 - JANUARY;
+ int dom = cal.get(DATE);
+ int dow = cal.get(DAY_OF_WEEK);
- logln("Changeover " + (i>=0?"+":"") + i +
- " days: " + y + "/" + mon + "/" + dom + " dow=" + dow);
+ logln("Changeover " + (i >= 0 ? "+" : "") + i
+ + " days: " + y + "/" + mon + "/" + dom + " dow=" + dow);
if (y != 1582 || mon != MON[j] || dom != DOM[j] || dow != DOW[j]) {
errln(" Fail: Above line is wrong");
}
}
- }
- finally {
+ } finally {
TimeZone.setDefault(savedZone);
}
}
@@ -99,22 +111,22 @@
* of this test, we don't care about timezones and week data
* (first day of week, minimal days in first week).
*/
+ @SuppressWarnings("deprecation")
public void TestMapping() {
TimeZone saveZone = TimeZone.getDefault();
int[] DATA = {
- // Julian# Year Month DOM JULIAN:Year, Month, DOM
- 2440588, 1970, Calendar.JANUARY, 1, 1969, Calendar.DECEMBER, 19,
- 2415080, 1900, Calendar.MARCH, 1, 1900, Calendar.FEBRUARY, 17,
- 2451604, 2000, Calendar.FEBRUARY, 29, 2000, Calendar.FEBRUARY, 16,
- 2452269, 2001, Calendar.DECEMBER, 25, 2001, Calendar.DECEMBER, 12,
- 2416526, 1904, Calendar.FEBRUARY, 15, 1904, Calendar.FEBRUARY, 2,
- 2416656, 1904, Calendar.JUNE, 24, 1904, Calendar.JUNE, 11,
- 1721426, 1, Calendar.JANUARY, 1, 1, Calendar.JANUARY, 3,
- 2000000, 763, Calendar.SEPTEMBER, 18, 763, Calendar.SEPTEMBER, 14,
- 4000000, 6239, Calendar.JULY, 12, 6239, Calendar.MAY, 28,
- 8000000, 17191, Calendar.FEBRUARY, 26, 17190, Calendar.OCTOBER, 22,
- 10000000, 22666, Calendar.DECEMBER, 20, 22666, Calendar.JULY, 5,
- };
+ // Julian# Year Month DOM JULIAN:Year Month, DOM
+ 2440588, 1970, JANUARY, 1, 1969, DECEMBER, 19,
+ 2415080, 1900, MARCH, 1, 1900, FEBRUARY, 17,
+ 2451604, 2000, FEBRUARY, 29, 2000, FEBRUARY, 16,
+ 2452269, 2001, DECEMBER, 25, 2001, DECEMBER, 12,
+ 2416526, 1904, FEBRUARY, 15, 1904, FEBRUARY, 2,
+ 2416656, 1904, JUNE, 24, 1904, JUNE, 11,
+ 1721426, 1, JANUARY, 1, 1, JANUARY, 3,
+ 2000000, 763, SEPTEMBER, 18, 763, SEPTEMBER, 14,
+ 4000000, 6239, JULY, 12, 6239, MAY, 28,
+ 8000000, 17191, FEBRUARY, 26, 17190, OCTOBER, 22,
+ 10000000, 22666, DECEMBER, 20, 22666, JULY, 5};
try {
TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
@@ -123,11 +135,11 @@
GregorianCalendar cal = new GregorianCalendar();
for (int i = 0; i < DATA.length; i += 7) {
int julian = DATA[i];
- int year = DATA[i+1];
- int month = DATA[i+2];
- int dom = DATA[i+3];
+ int year = DATA[i + 1];
+ int month = DATA[i + 2];
+ int dom = DATA[i + 3];
int year2, month2, dom2;
- long millis = ((long)julian - EPOCH_JULIAN) * ONE_DAY;
+ long millis = ((long) julian - EPOCH_JULIAN) * ONE_DAY;
String s;
// Test Gregorian computation
@@ -137,56 +149,55 @@
long calMillis = cal.getTime().getTime();
long delta = calMillis - millis;
cal.setTime(new Date(millis));
- year2 = cal.get(Calendar.YEAR);
- month2 = cal.get(Calendar.MONTH);
- dom2 = cal.get(Calendar.DAY_OF_MONTH);
- s = "G " + year + "-" + (month+1-Calendar.JANUARY) + "-" + dom +
- " => " + calMillis +
- " (" + ((float)delta/ONE_DAY) + " day delta) => " +
- year2 + "-" + (month2+1-Calendar.JANUARY) + "-" + dom2;
- if (delta != 0 || year != year2 || month != month2 ||
- dom != dom2) {
+ year2 = cal.get(YEAR);
+ month2 = cal.get(MONTH);
+ dom2 = cal.get(DAY_OF_MONTH);
+ s = "G " + year + "-" + (month + 1 - JANUARY) + "-" + dom
+ + " => " + calMillis
+ + " (" + ((float) delta / ONE_DAY) + " day delta) => "
+ + year2 + "-" + (month2 + 1 - JANUARY) + "-" + dom2;
+ if (delta != 0 || year != year2 || month != month2
+ || dom != dom2) {
errln(s + " FAIL");
} else {
logln(s);
}
// Test Julian computation
- year = DATA[i+4];
- month = DATA[i+5];
- dom = DATA[i+6];
+ year = DATA[i + 4];
+ month = DATA[i + 5];
+ dom = DATA[i + 6];
cal.setGregorianChange(PURE_JULIAN);
cal.clear();
cal.set(year, month, dom);
calMillis = cal.getTime().getTime();
delta = calMillis - millis;
cal.setTime(new Date(millis));
- year2 = cal.get(Calendar.YEAR);
- month2 = cal.get(Calendar.MONTH);
- dom2 = cal.get(Calendar.DAY_OF_MONTH);
- s = "J " + year + "-" + (month+1-Calendar.JANUARY) + "-" + dom +
- " => " + calMillis +
- " (" + ((float)delta/ONE_DAY) + " day delta) => " +
- year2 + "-" + (month2+1-Calendar.JANUARY) + "-" + dom2;
- if (delta != 0 || year != year2 || month != month2 ||
- dom != dom2) {
+ year2 = cal.get(YEAR);
+ month2 = cal.get(MONTH);
+ dom2 = cal.get(DAY_OF_MONTH);
+ s = "J " + year + "-" + (month + 1 - JANUARY) + "-" + dom
+ + " => " + calMillis
+ + " (" + ((float) delta / ONE_DAY) + " day delta) => "
+ + year2 + "-" + (month2 + 1 - JANUARY) + "-" + dom2;
+ if (delta != 0 || year != year2 || month != month2
+ || dom != dom2) {
errln(s + " FAIL");
} else {
logln(s);
}
}
- cal.setGregorianChange(new Date(1582-1900, Calendar.OCTOBER, 15));
- auxMapping(cal, 1582, Calendar.OCTOBER, 4);
- auxMapping(cal, 1582, Calendar.OCTOBER, 15);
- auxMapping(cal, 1582, Calendar.OCTOBER, 16);
- for (int y = 800; y < 3000; y += 1+(int)100*Math.random()) {
- for (int m = Calendar.JANUARY; m <= Calendar.DECEMBER; ++m) {
+ cal.setGregorianChange(new Date(1582 - 1900, OCTOBER, 15));
+ auxMapping(cal, 1582, OCTOBER, 4);
+ auxMapping(cal, 1582, OCTOBER, 15);
+ auxMapping(cal, 1582, OCTOBER, 16);
+ for (int y = 800; y < 3000; y += 1 + 100 * Math.random()) {
+ for (int m = JANUARY; m <= DECEMBER; ++m) {
auxMapping(cal, y, m, 15);
}
}
- }
- finally {
+ } finally {
TimeZone.setDefault(saveZone);
}
}
@@ -195,14 +206,16 @@
cal.set(y, m, d);
long millis = cal.getTime().getTime();
cal.setTime(new Date(millis));
- int year2 = cal.get(Calendar.YEAR);
- int month2 = cal.get(Calendar.MONTH);
- int dom2 = cal.get(Calendar.DAY_OF_MONTH);
- if (y != year2 || m != month2 || dom2 != d)
- errln("Round-trip failure: " + y + "-" + (m+1) + "-"+d+" =>ms=> " +
- year2 + "-" + (month2+1) + "-" + dom2);
+ int year2 = cal.get(YEAR);
+ int month2 = cal.get(MONTH);
+ int dom2 = cal.get(DAY_OF_MONTH);
+ if (y != year2 || m != month2 || dom2 != d) {
+ errln("Round-trip failure: " + y + "-" + (m + 1) + "-" + d + " =>ms=> "
+ + year2 + "-" + (month2 + 1) + "-" + dom2);
+ }
}
+ @SuppressWarnings("deprecation")
public void TestGenericAPI() {
Locale locale = Locale.getDefault();
if (!TestUtils.usesGregorianCalendar(locale)) {
@@ -211,76 +224,95 @@
}
String str;
-
- Date when = new Date(90, Calendar.APRIL, 15);
+ Date when = new Date(90, APRIL, 15);
String tzid = "TestZone";
int tzoffset = 123400;
SimpleTimeZone zone = new SimpleTimeZone(tzoffset, tzid);
- Calendar cal = (Calendar)Calendar.getInstance((SimpleTimeZone)zone.clone());
+ Calendar cal = Calendar.getInstance((SimpleTimeZone) zone.clone());
- if (!zone.equals(cal.getTimeZone())) errln("FAIL: Calendar.getTimeZone failed");
+ if (!zone.equals(cal.getTimeZone())) {
+ errln("FAIL: Calendar.getTimeZone failed");
+ }
Calendar cal2 = Calendar.getInstance(cal.getTimeZone());
cal.setTime(when);
cal2.setTime(when);
- if (!(cal.equals(cal2))) errln("FAIL: Calendar.operator== failed");
+ if (!(cal.equals(cal2))) {
+ errln("FAIL: Calendar.operator== failed");
+ }
// if ((*cal != *cal2)) errln("FAIL: Calendar.operator!= failed");
- if (!cal.equals(cal2) ||
- cal.before(cal2) ||
- cal.after(cal2)) errln("FAIL: equals/before/after failed");
+ if (!cal.equals(cal2)
+ || cal.before(cal2)
+ || cal.after(cal2)) {
+ errln("FAIL: equals/before/after failed");
+ }
cal2.setTime(new Date(when.getTime() + 1000));
- if (cal.equals(cal2) ||
- cal2.before(cal) ||
- cal.after(cal2)) errln("FAIL: equals/before/after failed");
+ if (cal.equals(cal2)
+ || cal2.before(cal)
+ || cal.after(cal2)) {
+ errln("FAIL: equals/before/after failed");
+ }
- cal.roll(Calendar.SECOND, true);
- if (!cal.equals(cal2) ||
- cal.before(cal2) ||
- cal.after(cal2)) errln("FAIL: equals/before/after failed");
+ cal.roll(SECOND, true);
+ if (!cal.equals(cal2)
+ || cal.before(cal2)
+ || cal.after(cal2)) {
+ errln("FAIL: equals/before/after failed");
+ }
// Roll back to January
- cal.roll(Calendar.MONTH, (int)(1 + Calendar.DECEMBER - cal.get(Calendar.MONTH)));
- if (cal.equals(cal2) ||
- cal2.before(cal) ||
- cal.after(cal2)) errln("FAIL: equals/before/after failed");
+ cal.roll(MONTH, 1 + DECEMBER - cal.get(MONTH));
+ if (cal.equals(cal2)
+ || cal2.before(cal)
+ || cal.after(cal2)) {
+ errln("FAIL: equals/before/after failed");
+ }
// C++ only
/* TimeZone z = cal.orphanTimeZone();
- if (z.getID(str) != tzid ||
- z.getRawOffset() != tzoffset)
- errln("FAIL: orphanTimeZone failed");
- */
-
+ if (z.getID(str) != tzid ||
+ z.getRawOffset() != tzoffset)
+ errln("FAIL: orphanTimeZone failed");
+ */
for (int i = 0; i < 2; ++i) {
- boolean lenient = ( i > 0 );
+ boolean lenient = (i > 0);
cal.setLenient(lenient);
- if (lenient != cal.isLenient()) errln("FAIL: setLenient/isLenient failed");
+ if (lenient != cal.isLenient()) {
+ errln("FAIL: setLenient/isLenient failed");
+ }
// Later: Check for lenient behavior
}
int i;
- for (i = Calendar.SUNDAY; i <= Calendar.SATURDAY; ++i) {
+ for (i = SUNDAY; i <= SATURDAY; ++i) {
cal.setFirstDayOfWeek(i);
- if (cal.getFirstDayOfWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");
+ if (cal.getFirstDayOfWeek() != i) {
+ errln("FAIL: set/getFirstDayOfWeek failed");
+ }
}
for (i = 0; i <= 7; ++i) {
cal.setMinimalDaysInFirstWeek(i);
- if (cal.getMinimalDaysInFirstWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");
+ if (cal.getMinimalDaysInFirstWeek() != i) {
+ errln("FAIL: set/getFirstDayOfWeek failed");
+ }
}
- for (i = 0; i < Calendar.FIELD_COUNT; ++i) {
- if (cal.getMinimum(i) != cal.getGreatestMinimum(i))
+ for (i = 0; i < FIELD_COUNT; ++i) {
+ if (cal.getMinimum(i) != cal.getGreatestMinimum(i)) {
errln("FAIL: getMinimum doesn't match getGreatestMinimum for field " + i);
- if (cal.getLeastMaximum(i) > cal.getMaximum(i))
+ }
+ if (cal.getLeastMaximum(i) > cal.getMaximum(i)) {
errln("FAIL: getLeastMaximum larger than getMaximum for field " + i);
- if (cal.getMinimum(i) >= cal.getMaximum(i))
+ }
+ if (cal.getMinimum(i) >= cal.getMaximum(i)) {
errln("FAIL: getMinimum not less than getMaximum for field " + i);
+ }
}
cal.setTimeZone(TimeZone.getDefault());
@@ -306,30 +338,36 @@
}
cal.getTime();
- for (i = 0; i < Calendar.FIELD_COUNT; ++i) {
- switch(i) {
- case Calendar.YEAR: case Calendar.MONTH: case Calendar.DATE:
- case Calendar.HOUR_OF_DAY: case Calendar.MINUTE: case Calendar.SECOND:
- if (!cal.isSet(i))
- errln("FAIL: !Calendar.isSet test failed: " + calendarFieldNames[i]);
- break;
- default:
- if (cal.isSet(i))
- errln("FAIL: Calendar.isSet test failed: " + calendarFieldNames[i]);
+ for (i = 0; i < FIELD_COUNT; ++i) {
+ switch (i) {
+ case YEAR:
+ case MONTH:
+ case DATE:
+ case HOUR_OF_DAY:
+ case MINUTE:
+ case SECOND:
+ if (!cal.isSet(i)) {
+ errln("FAIL: !Calendar.isSet test failed: " + calendarFieldNames[i]);
+ }
+ break;
+ default:
+ if (cal.isSet(i)) {
+ errln("FAIL: Calendar.isSet test failed: " + calendarFieldNames[i]);
+ }
}
cal.clear(i);
- if (cal.isSet(i)) errln("FAIL: Calendar.clear/isSet failed");
+ if (cal.isSet(i)) {
+ errln("FAIL: Calendar.clear/isSet failed");
+ }
}
// delete cal;
// delete cal2;
-
Locale[] loc = Calendar.getAvailableLocales();
long count = loc.length;
if (count < 1 || loc == null) {
errln("FAIL: getAvailableLocales failed");
- }
- else {
+ } else {
for (i = 0; i < count; ++i) {
cal = Calendar.getInstance(loc[i]);
// delete cal;
@@ -358,13 +396,15 @@
// delete gc;
gc = new GregorianCalendar(1998, 10, 14, 21, 43);
- if (gc.getTime().getTime() != new Date(98, 10, 14, 21, 43).getTime())
+ if (gc.getTime().getTime() != new Date(98, 10, 14, 21, 43).getTime()) {
errln("FAIL: new GregorianCalendar(ymdhm) failed");
+ }
// delete gc;
gc = new GregorianCalendar(1998, 10, 14, 21, 43, 55);
- if (gc.getTime().getTime() != new Date(98, 10, 14, 21, 43, 55).getTime())
+ if (gc.getTime().getTime() != new Date(98, 10, 14, 21, 43, 55).getTime()) {
errln("FAIL: new GregorianCalendar(ymdhms) failed");
+ }
// C++ only:
// GregorianCalendar gc2 = new GregorianCalendar(Locale.ENGLISH);
@@ -378,19 +418,20 @@
public void TestRog() {
GregorianCalendar gc = new GregorianCalendar();
- int year = 1997, month = Calendar.APRIL, date = 1;
+ int year = 1997, month = APRIL, date = 1;
gc.set(year, month, date); // April 1, 1997
- gc.set(Calendar.HOUR_OF_DAY, 23);
- gc.set(Calendar.MINUTE, 0);
- gc.set(Calendar.SECOND, 0);
- gc.set(Calendar.MILLISECOND, 0);
+ gc.set(HOUR_OF_DAY, 23);
+ gc.set(MINUTE, 0);
+ gc.set(SECOND, 0);
+ gc.set(MILLISECOND, 0);
- for (int i = 0; i < 9; i++, gc.add(Calendar.DATE, 1)) {
- if (gc.get(Calendar.YEAR) != year ||
- gc.get(Calendar.MONTH) != month ||
- gc.get(Calendar.DATE) != (date + i))
+ for (int i = 0; i < 9; i++, gc.add(DATE, 1)) {
+ if (gc.get(YEAR) != year
+ || gc.get(MONTH) != month
+ || gc.get(DATE) != (date + i)) {
errln("FAIL: Date " + gc.getTime() + " wrong");
+ }
}
}
@@ -402,162 +443,172 @@
void dowTest(boolean lenient) {
GregorianCalendar cal = new GregorianCalendar();
- cal.set(1997, Calendar.AUGUST, 12); // Wednesday
+ cal.set(1997, AUGUST, 12); // Wednesday
cal.getTime(); // Force update
cal.setLenient(lenient);
- cal.set(1996, Calendar.DECEMBER, 1); // Set the date to be December 1, 1996
- int dow = cal.get(Calendar.DAY_OF_WEEK);
- int min = cal.getMinimum(Calendar.DAY_OF_WEEK);
- int max = cal.getMaximum(Calendar.DAY_OF_WEEK);
- if (dow < min || dow > max) errln("FAIL: Day of week " + dow + " out of range");
- if (dow != Calendar.SUNDAY) {
+ cal.set(1996, DECEMBER, 1); // Set the date to be December 1, 1996
+ int dow = cal.get(DAY_OF_WEEK);
+ int min = cal.getMinimum(DAY_OF_WEEK);
+ int max = cal.getMaximum(DAY_OF_WEEK);
+ if (dow < min || dow > max) {
+ errln("FAIL: Day of week " + dow + " out of range");
+ }
+ if (dow != SUNDAY) {
errln("FAIL2: Day of week should be SUNDAY; is " + dow + ": " + cal.getTime());
}
- if (min != Calendar.SUNDAY || max != Calendar.SATURDAY) errln("FAIL: Min/max bad");
+ if (min != SUNDAY || max != SATURDAY) {
+ errln("FAIL: Min/max bad");
+ }
}
// Verify that the clone method produces distinct objects with no
// unintentionally shared fields.
public void TestClonesUnique908() {
Calendar c = Calendar.getInstance();
- Calendar d = (Calendar)c.clone();
- c.set(Calendar.MILLISECOND, 123);
- d.set(Calendar.MILLISECOND, 456);
- if (c.get(Calendar.MILLISECOND) != 123 ||
- d.get(Calendar.MILLISECOND) != 456) {
+ Calendar d = (Calendar) c.clone();
+ c.set(MILLISECOND, 123);
+ d.set(MILLISECOND, 456);
+ if (c.get(MILLISECOND) != 123
+ || d.get(MILLISECOND) != 456) {
errln("FAIL: Clones share fields");
}
}
// Verify effect of Gregorian cutoff value
+ @SuppressWarnings("deprecation")
public void TestGregorianChange768() {
boolean b;
GregorianCalendar c = new GregorianCalendar();
logln("With cutoff " + c.getGregorianChange());
- logln(" isLeapYear(1800) = " + (b=c.isLeapYear(1800)));
+ logln(" isLeapYear(1800) = " + (b = c.isLeapYear(1800)));
logln(" (should be FALSE)");
- if (b != false) errln("FAIL");
+ if (b != false) {
+ errln("FAIL");
+ }
c.setGregorianChange(new Date(0, 0, 1)); // Jan 1 1900
logln("With cutoff " + c.getGregorianChange());
- logln(" isLeapYear(1800) = " + (b=c.isLeapYear(1800)));
+ logln(" isLeapYear(1800) = " + (b = c.isLeapYear(1800)));
logln(" (should be TRUE)");
- if (b != true) errln("FAIL");
+ if (b != true) {
+ errln("FAIL");
+ }
}
// Test the correct behavior of the disambiguation algorithm.
public void TestDisambiguation765() throws Exception {
- Locale savedLocale = Locale.getDefault();
- try {
- Locale.setDefault(Locale.US);
- Calendar c = Calendar.getInstance();
- c.setLenient(false);
+ Locale savedLocale = Locale.getDefault();
+ try {
+ Locale.setDefault(Locale.US);
+ Calendar c = Calendar.getInstance();
+ c.setLenient(false);
- c.clear();
- c.set(Calendar.YEAR, 1997);
- c.set(Calendar.MONTH, Calendar.JUNE);
- c.set(Calendar.DATE, 3);
+ c.clear();
+ c.set(YEAR, 1997);
+ c.set(MONTH, JUNE);
+ c.set(DATE, 3);
- verify765("1997 third day of June = ", c, 1997, Calendar.JUNE, 3);
+ verify765("1997 third day of June = ", c, 1997, JUNE, 3);
- c.clear();
- c.set(Calendar.YEAR, 1997);
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
- c.set(Calendar.MONTH, Calendar.JUNE);
- c.set(Calendar.DAY_OF_WEEK_IN_MONTH, 1);
- verify765("1997 first Tuesday in June = ", c, 1997, Calendar.JUNE, 3);
+ c.clear();
+ c.set(YEAR, 1997);
+ c.set(DAY_OF_WEEK, TUESDAY);
+ c.set(MONTH, JUNE);
+ c.set(DAY_OF_WEEK_IN_MONTH, 1);
+ verify765("1997 first Tuesday in June = ", c, 1997, JUNE, 3);
- c.setLenient(true); // for 4944795
- c.clear();
- c.set(Calendar.YEAR, 1997);
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
- c.set(Calendar.MONTH, Calendar.JUNE);
- c.set(Calendar.DAY_OF_WEEK_IN_MONTH, -1);
- verify765("1997 last Tuesday in June = ", c, 1997, Calendar.JUNE, 24);
-
- c.setLenient(false);
- IllegalArgumentException e = null;
- try {
+ c.setLenient(true); // for 4944795
c.clear();
- c.set(Calendar.YEAR, 1997);
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
- c.set(Calendar.MONTH, Calendar.JUNE);
- c.set(Calendar.DAY_OF_WEEK_IN_MONTH, 0);
- c.getTime();
- }
- catch (IllegalArgumentException ex) {
- e = ex;
- }
- verify765("1997 zero-th Tuesday in June = ", e);
+ c.set(YEAR, 1997);
+ c.set(DAY_OF_WEEK, TUESDAY);
+ c.set(MONTH, JUNE);
+ c.set(DAY_OF_WEEK_IN_MONTH, -1);
+ verify765("1997 last Tuesday in June = ", c, 1997, JUNE, 24);
- c.clear();
- c.set(Calendar.YEAR, 1997);
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
- c.set(Calendar.MONTH, Calendar.JUNE);
- c.set(Calendar.WEEK_OF_MONTH, 1);
- verify765("1997 Tuesday in week 1 of June = ", c, 1997, Calendar.JUNE, 3);
+ c.setLenient(false);
+ IllegalArgumentException e = null;
+ try {
+ c.clear();
+ c.set(YEAR, 1997);
+ c.set(DAY_OF_WEEK, TUESDAY);
+ c.set(MONTH, JUNE);
+ c.set(DAY_OF_WEEK_IN_MONTH, 0);
+ c.getTime();
+ } catch (IllegalArgumentException ex) {
+ e = ex;
+ }
+ verify765("1997 zero-th Tuesday in June = ", e);
- c.clear();
- c.set(Calendar.YEAR, 1997);
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
- c.set(Calendar.MONTH, Calendar.JUNE);
- c.set(Calendar.WEEK_OF_MONTH, 4);
- verify765("1997 Tuesday in week 4 of June = ", c, 1997, Calendar.JUNE, 24);
-
- try {
c.clear();
- c.set(Calendar.YEAR, 1997);
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
- c.set(Calendar.MONTH, Calendar.JUNE);
- c.set(Calendar.WEEK_OF_MONTH, 1);
- verify765("1997 Tuesday in week 0 of June = ", c, 1997, Calendar.JUNE, 3);
- }
- catch (IllegalArgumentException ex) {
- errln("FAIL: Exception seen: " + ex.getMessage());
- // ex.printStackTrace(log);
- }
+ c.set(YEAR, 1997);
+ c.set(DAY_OF_WEEK, TUESDAY);
+ c.set(MONTH, JUNE);
+ c.set(WEEK_OF_MONTH, 1);
+ verify765("1997 Tuesday in week 1 of June = ", c, 1997, JUNE, 3);
- c.clear();
- c.set(Calendar.YEAR, 1997);
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
- c.set(Calendar.WEEK_OF_YEAR, 2);
- verify765("1997 Tuesday in week 2 of year = ", c, 1997, Calendar.JANUARY, 7);
+ c.clear();
+ c.set(YEAR, 1997);
+ c.set(DAY_OF_WEEK, TUESDAY);
+ c.set(MONTH, JUNE);
+ c.set(WEEK_OF_MONTH, 4);
+ verify765("1997 Tuesday in week 4 of June = ", c, 1997, JUNE, 24);
- c.clear();
- c.set(Calendar.YEAR, 1997);
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
- c.set(Calendar.WEEK_OF_YEAR, 10);
- verify765("1997 Tuesday in week 10 of year = ", c, 1997, Calendar.MARCH, 4);
+ try {
+ c.clear();
+ c.set(YEAR, 1997);
+ c.set(DAY_OF_WEEK, TUESDAY);
+ c.set(MONTH, JUNE);
+ c.set(WEEK_OF_MONTH, 1);
+ verify765("1997 Tuesday in week 0 of June = ", c, 1997, JUNE, 3);
+ } catch (IllegalArgumentException ex) {
+ errln("FAIL: Exception seen: " + ex.getMessage());
+ // ex.printStackTrace(log);
+ }
- try {
c.clear();
- c.set(Calendar.YEAR, 1997);
- c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
- c.set(Calendar.WEEK_OF_YEAR, 0);
- verify765("1997 Tuesday in week 0 of year = ", c, 1996, Calendar.DECEMBER, 24);
- throw new Exception("Fail: WEEK_OF_YEAR 0 should be illegal");
- }
- catch (IllegalArgumentException ex) {}
- }
- finally {
- Locale.setDefault(savedLocale);
- }
- }
- void verify765(String msg, Calendar c, int year, int month, int day) {
- if (c.get(Calendar.YEAR) == year &&
- c.get(Calendar.MONTH) == month &&
- c.get(Calendar.DATE) == day) {
- logln("PASS: " + msg + c.getTime());
- }
- else {
- errln("FAIL: " + msg + c.getTime() +
- "; expected " +
- year + "/" + (month+1) + "/" + day);
+ c.set(YEAR, 1997);
+ c.set(DAY_OF_WEEK, TUESDAY);
+ c.set(WEEK_OF_YEAR, 2);
+ verify765("1997 Tuesday in week 2 of year = ", c, 1997, JANUARY, 7);
+
+ c.clear();
+ c.set(YEAR, 1997);
+ c.set(DAY_OF_WEEK, TUESDAY);
+ c.set(WEEK_OF_YEAR, 10);
+ verify765("1997 Tuesday in week 10 of year = ", c, 1997, MARCH, 4);
+
+ try {
+ c.clear();
+ c.set(YEAR, 1997);
+ c.set(DAY_OF_WEEK, TUESDAY);
+ c.set(WEEK_OF_YEAR, 0);
+ verify765("1997 Tuesday in week 0 of year = ", c, 1996, DECEMBER, 24);
+ throw new Exception("Fail: WEEK_OF_YEAR 0 should be illegal");
+ } catch (IllegalArgumentException ex) {
+ }
+ } finally {
+ Locale.setDefault(savedLocale);
}
}
+
+ void verify765(String msg, Calendar c, int year, int month, int day) {
+ if (c.get(YEAR) == year
+ && c.get(MONTH) == month
+ && c.get(DATE) == day) {
+ logln("PASS: " + msg + c.getTime());
+ } else {
+ errln("FAIL: " + msg + c.getTime()
+ + "; expected "
+ + year + "/" + (month + 1) + "/" + day);
+ }
+ }
+
// Called when e expected to be non-null
void verify765(String msg, IllegalArgumentException e) {
- if (e == null) errln("FAIL: No IllegalArgumentException for " + msg);
- else logln("PASS: " + msg + "IllegalArgument as expected");
+ if (e == null) {
+ errln("FAIL: No IllegalArgumentException for " + msg);
+ } else {
+ logln("PASS: " + msg + "IllegalArgument as expected");
+ }
}
// Test the behavior of GMT vs. local time
@@ -588,106 +639,112 @@
Date date;
Calendar gmtcal = Calendar.getInstance();
gmtcal.setTimeZone(TimeZone.getTimeZone("Africa/Casablanca"));
- gmtcal.set(yr, mo-1, dt, hr, mn, sc);
- gmtcal.set(Calendar.MILLISECOND, 0);
+ gmtcal.set(yr, mo - 1, dt, hr, mn, sc);
+ gmtcal.set(MILLISECOND, 0);
date = gmtcal.getTime();
- logln("date = "+date);
+ logln("date = " + date);
Calendar cal = Calendar.getInstance();
cal.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
cal.setTime(date);
- int offset = cal.getTimeZone().getOffset(cal.get(Calendar.ERA),
- cal.get(Calendar.YEAR),
- cal.get(Calendar.MONTH),
- cal.get(Calendar.DATE),
- cal.get(Calendar.DAY_OF_WEEK),
- cal.get(Calendar.MILLISECOND));
+ int offset = cal.getTimeZone().getOffset(cal.get(ERA),
+ cal.get(YEAR),
+ cal.get(MONTH),
+ cal.get(DATE),
+ cal.get(DAY_OF_WEEK),
+ cal.get(MILLISECOND));
- logln("offset for "+date+"= "+(offset/1000/60/60.0) + "hr");
+ logln("offset for " + date + "= " + (offset / 1000 / 60 / 60.0) + "hr");
- int utc = ((cal.get(Calendar.HOUR_OF_DAY) * 60 +
- cal.get(Calendar.MINUTE)) * 60 +
- cal.get(Calendar.SECOND)) * 1000 +
- cal.get(Calendar.MILLISECOND) - offset;
+ int utc = ((cal.get(HOUR_OF_DAY) * 60
+ + cal.get(MINUTE)) * 60
+ + cal.get(SECOND)) * 1000
+ + cal.get(MILLISECOND) - offset;
int expected = ((hr * 60 + mn) * 60 + sc) * 1000;
- if (utc != expected)
- errln("FAIL: Discrepancy of " +
- (utc - expected) + " millis = " +
- ((utc-expected)/1000/60/60.0) + " hr");
+ if (utc != expected) {
+ errln("FAIL: Discrepancy of "
+ + (utc - expected) + " millis = "
+ + ((utc - expected) / 1000 / 60 / 60.0) + " hr");
+ }
}
// Verify that add and set work regardless of the order in which
// they are called.
public void TestAddSetOrder621() {
+ @SuppressWarnings("deprecation")
Date d = new Date(97, 4, 14, 13, 23, 45);
- Calendar cal = Calendar.getInstance ();
- cal.setTime (d);
- cal.add (Calendar.DATE, -5);
- cal.set (Calendar.HOUR_OF_DAY, 0);
- cal.set (Calendar.MINUTE, 0);
- cal.set (Calendar.SECOND, 0);
+ Calendar cal = Calendar.getInstance();
+ cal.setTime(d);
+ cal.add(DATE, -5);
+ cal.set(HOUR_OF_DAY, 0);
+ cal.set(MINUTE, 0);
+ cal.set(SECOND, 0);
// ma feb 03 00:00:00 GMT+00:00 1997
- String s = cal.getTime ().toString ();
+ String s = cal.getTime().toString();
- cal = Calendar.getInstance ();
- cal.setTime (d);
- cal.set (Calendar.HOUR_OF_DAY, 0);
- cal.set (Calendar.MINUTE, 0);
- cal.set (Calendar.SECOND, 0);
- cal.add (Calendar.DATE, -5);
+ cal = Calendar.getInstance();
+ cal.setTime(d);
+ cal.set(HOUR_OF_DAY, 0);
+ cal.set(MINUTE, 0);
+ cal.set(SECOND, 0);
+ cal.add(DATE, -5);
// ma feb 03 13:11:06 GMT+00:00 1997
- String s2 = cal.getTime ().toString ();
+ String s2 = cal.getTime().toString();
- if (s.equals(s2))
+ if (s.equals(s2)) {
logln("Pass: " + s + " == " + s2);
- else
+ } else {
errln("FAIL: " + s + " != " + s2);
+ }
}
// Verify that add works.
public void TestAdd520() {
- int y = 1997, m = Calendar.FEBRUARY, d = 1;
- GregorianCalendar temp = new GregorianCalendar( y, m, d );
+ int y = 1997, m = FEBRUARY, d = 1;
+ GregorianCalendar temp = new GregorianCalendar(y, m, d);
check520(temp, y, m, d);
- temp.add( temp.YEAR, 1 );
+ temp.add(YEAR, 1);
y++;
check520(temp, y, m, d);
- temp.add( temp.MONTH, 1 );
+ temp.add(MONTH, 1);
m++;
check520(temp, y, m, d);
- temp.add( temp.DATE, 1 );
+ temp.add(DATE, 1);
d++;
check520(temp, y, m, d);
- temp.add( temp.DATE, 2 );
+ temp.add(DATE, 2);
d += 2;
check520(temp, y, m, d);
- temp.add( temp.DATE, 28 );
- d = 1; ++m;
+ temp.add(DATE, 28);
+ d = 1;
+ ++m;
check520(temp, y, m, d);
}
+
void check520(Calendar c, int y, int m, int d) {
- if (c.get(Calendar.YEAR) != y ||
- c.get(Calendar.MONTH) != m ||
- c.get(Calendar.DATE) != d) {
- errln("FAILURE: Expected YEAR/MONTH/DATE of " +
- y + "/" + (m+1) + "/" + d +
- "; got " +
- c.get(Calendar.YEAR) + "/" +
- (c.get(Calendar.MONTH)+1) + "/" +
- c.get(Calendar.DATE));
+ if (c.get(YEAR) != y
+ || c.get(MONTH) != m
+ || c.get(DATE) != d) {
+ errln("FAILURE: Expected YEAR/MONTH/DATE of "
+ + y + "/" + (m + 1) + "/" + d
+ + "; got "
+ + c.get(YEAR) + "/"
+ + (c.get(MONTH) + 1) + "/"
+ + c.get(DATE));
+ } else {
+ logln("Confirmed: "
+ + y + "/" + (m + 1) + "/" + d);
}
- else logln("Confirmed: " +
- y + "/" + (m+1) + "/" + d);
}
// Verify that setting fields works. This test fails when an exception is thrown.
@@ -697,18 +754,18 @@
GregorianCalendar g2 = new GregorianCalendar();
// At this point UTC value is set, various fields are not.
// Now set to noon.
- g2.set(Calendar.HOUR, 12);
- g2.set(Calendar.MINUTE, 0);
- g2.set(Calendar.SECOND, 0);
+ g2.set(HOUR, 12);
+ g2.set(MINUTE, 0);
+ g2.set(SECOND, 0);
// At this point the object thinks UTC is NOT set, but fields are set.
// The following line will result in IllegalArgumentException because
// it thinks the YEAR is set and it is NOT.
- if (g2.equals(g))
+ if (g2.equals(g)) {
logln("Same");
- else
+ } else {
logln("Different");
- }
- catch (IllegalArgumentException e) {
+ }
+ } catch (IllegalArgumentException e) {
errln("Unexpected exception seen: " + e);
}
}
@@ -729,28 +786,28 @@
FileInputStream in = new FileInputStream(FILENAME);
ObjectInputStream t = new ObjectInputStream(in);
- String pre = (String)t.readObject();
- Calendar c = (Calendar)t.readObject();
- String post = (String)t.readObject();
+ String pre = (String) t.readObject();
+ Calendar c = (Calendar) t.readObject();
+ String post = (String) t.readObject();
in.close();
- ok = pre.equals(PREFIX) &&
- post.equals(POSTFIX) &&
- cal.equals(c);
+ ok = pre.equals(PREFIX)
+ && post.equals(POSTFIX)
+ && cal.equals(c);
File fl = new File(FILENAME);
fl.delete();
- }
- catch (IOException e) {
+ } catch (IOException e) {
errln("FAIL: Exception received:");
// e.printStackTrace(log);
- }
- catch (ClassNotFoundException e) {
+ } catch (ClassNotFoundException e) {
errln("FAIL: Exception received:");
// e.printStackTrace(log);
}
- if (!ok) errln("Serialization of Calendar object failed.");
+ if (!ok) {
+ errln("Serialization of Calendar object failed.");
+ }
}
static final String PREFIX = "abc";
static final String POSTFIX = "def";
@@ -758,14 +815,16 @@
// Try to zero out the seconds field
public void TestSecondsZero121() {
- Calendar cal = new GregorianCalendar();
+ Calendar cal = new GregorianCalendar();
// Initialize with current date/time
cal.setTime(new Date());
// Round down to minute
- cal.set(Calendar.SECOND, 0);
- Date d = cal.getTime();
+ cal.set(SECOND, 0);
+ Date d = cal.getTime();
String s = d.toString();
- if (s.indexOf(":00 ") < 0) errln("Expected to see :00 in " + s);
+ if (s.indexOf(":00 ") < 0) {
+ errln("Expected to see :00 in " + s);
+ }
}
// Try various sequences of add, set, and get method calls.
@@ -777,15 +836,17 @@
// - Addition uses millis which are still *now*
//
{
- Calendar calendar = new GregorianCalendar( ) ;
- calendar.set( 1993, Calendar.JANUARY, 4 ) ;
- logln( "1A) " + value( calendar ) ) ;
- calendar.add( Calendar.DATE, 1 ) ;
+ Calendar calendar = new GregorianCalendar();
+ calendar.set(1993, JANUARY, 4);
+ logln("1A) " + value(calendar));
+ calendar.add(DATE, 1);
String v = value(calendar);
- logln( "1B) " + v );
- logln( "--) 1993/0/5" ) ;
- if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +
- "; saw " + v);
+ logln("1B) " + v);
+ logln("--) 1993/0/5");
+ if (!v.equals(EXPECTED_0610)) {
+ errln("Expected " + EXPECTED_0610
+ + "; saw " + v);
+ }
}
//
@@ -793,16 +854,17 @@
// - Upon initialization calendar fields set, millis = 0
// - Addition uses millis which are still 1970, 0, 1
//
-
{
- Calendar calendar = new GregorianCalendar( 1993, Calendar.JANUARY, 4 ) ;
- logln( "2A) " + value( calendar ) ) ;
- calendar.add( Calendar.DATE, 1 ) ;
+ Calendar calendar = new GregorianCalendar(1993, JANUARY, 4);
+ logln("2A) " + value(calendar));
+ calendar.add(DATE, 1);
String v = value(calendar);
- logln( "2B) " + v );
- logln( "--) 1993/0/5" ) ;
- if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +
- "; saw " + v);
+ logln("2B) " + v);
+ logln("--) 1993/0/5");
+ if (!v.equals(EXPECTED_0610)) {
+ errln("Expected " + EXPECTED_0610
+ + "; saw " + v);
+ }
}
//
@@ -811,102 +873,99 @@
// - getTime( ) is called which forces the millis to be set
// - Addition uses millis which are correct
//
-
{
- Calendar calendar = new GregorianCalendar( 1993, Calendar.JANUARY, 4 ) ;
- logln( "3A) " + value( calendar ) ) ;
- calendar.getTime( ) ;
- calendar.add( Calendar.DATE, 1 ) ;
+ Calendar calendar = new GregorianCalendar(1993, JANUARY, 4);
+ logln("3A) " + value(calendar));
+ calendar.getTime();
+ calendar.add(DATE, 1);
String v = value(calendar);
- logln( "3B) " + v ) ;
- logln( "--) 1993/0/5" ) ;
- if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +
- "; saw " + v);
+ logln("3B) " + v);
+ logln("--) 1993/0/5");
+ if (!v.equals(EXPECTED_0610)) {
+ errln("Expected " + EXPECTED_0610
+ + "; saw " + v);
+ }
}
}
- static String value( Calendar calendar ) {
- return( calendar.get( Calendar.YEAR ) + "/" +
- calendar.get( Calendar.MONTH ) + "/" +
- calendar.get( Calendar.DATE ) ) ;
+ static String value(Calendar calendar) {
+ return (calendar.get(YEAR) + "/"
+ + calendar.get(MONTH) + "/"
+ + calendar.get(DATE));
}
static String EXPECTED_0610 = "1993/0/5";
// Test that certain fields on a certain date are as expected.
public void TestFields060() {
int year = 1997;
- int month = java.util.Calendar.OCTOBER; //october
+ int month = OCTOBER; //october
int dDate = 22; //DAYOFWEEK should return 3 for Wednesday
GregorianCalendar calendar = null;
- calendar = new GregorianCalendar( year, month, dDate);
- for (int i = 0; i < EXPECTED_FIELDS.length; ) {
+ calendar = new GregorianCalendar(year, month, dDate);
+ for (int i = 0; i < EXPECTED_FIELDS.length;) {
int field = EXPECTED_FIELDS[i++];
int expected = EXPECTED_FIELDS[i++];
if (calendar.get(field) != expected) {
- errln("Expected field " + field + " to have value " + expected +
- "; received " + calendar.get(field) + " instead");
+ errln("Expected field " + field + " to have value " + expected
+ + "; received " + calendar.get(field) + " instead");
}
}
}
- static int EXPECTED_FIELDS[] = {
- Calendar.YEAR, 1997,
- Calendar.MONTH, Calendar.OCTOBER,
- Calendar.DAY_OF_MONTH, 22,
- Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY,
- Calendar.DAY_OF_WEEK_IN_MONTH, 4,
- Calendar.DAY_OF_YEAR, 295
- };
+ static int[] EXPECTED_FIELDS = {
+ YEAR, 1997,
+ MONTH, OCTOBER,
+ DAY_OF_MONTH, 22,
+ DAY_OF_WEEK, WEDNESDAY,
+ DAY_OF_WEEK_IN_MONTH, 4,
+ DAY_OF_YEAR, 295};
static final String[] calendarFieldNames = {
- /* 0 */ "ERA",
- /* 1 */ "YEAR",
- /* 2 */ "MONTH",
- /* 3 */ "WEEK_OF_YEAR",
- /* 4 */ "WEEK_OF_MONTH",
- /* 5 */ "DAY_OF_MONTH",
- /* 6 */ "DAY_OF_YEAR",
- /* 7 */ "DAY_OF_WEEK",
- /* 8 */ "DAY_OF_WEEK_IN_MONTH",
- /* 9 */ "AM_PM",
- /* 10 */ "HOUR",
- /* 11 */ "HOUR_OF_DAY",
- /* 12 */ "MINUTE",
- /* 13 */ "SECOND",
- /* 14 */ "MILLISECOND",
- /* 15 */ "ZONE_OFFSET",
- /* 16 */ "DST_OFFSET"
- };
+ /* 0 */ "ERA",
+ /* 1 */ "YEAR",
+ /* 2 */ "MONTH",
+ /* 3 */ "WEEK_OF_YEAR",
+ /* 4 */ "WEEK_OF_MONTH",
+ /* 5 */ "DAY_OF_MONTH",
+ /* 6 */ "DAY_OF_YEAR",
+ /* 7 */ "DAY_OF_WEEK",
+ /* 8 */ "DAY_OF_WEEK_IN_MONTH",
+ /* 9 */ "AM_PM",
+ /* 10 */ "HOUR",
+ /* 11 */ "HOUR_OF_DAY",
+ /* 12 */ "MINUTE",
+ /* 13 */ "SECOND",
+ /* 14 */ "MILLISECOND",
+ /* 15 */ "ZONE_OFFSET",
+ /* 16 */ "DST_OFFSET"};
// Verify that the fields are as expected (mostly zero) at the epoch start.
// Note that we adjust for the default timezone to get most things to zero.
public void TestEpochStartFields() {
String[][] lt = {
- {"en", "US", "US/Pacific"}, /* First day = 1, Minimum day = 1 */
- {"en", "US", "America/Anchorage"}, /* First day = 1, Minimum day = 1 */
- {"en", "TO", "Pacific/Tongatapu"}, /* First day = 1, Minimum day = 1 */
- {"en", "MH", "Pacific/Majuro"}, /* First day = 1, Minimum day = 1 */
- {"ja", "JP", "Asia/Tokyo"}, /* First day = 1, Minimum day = 1 */
- {"iw", "IL", "Asia/Jerusalem"}, /* First day = 1, Minimum day = 1 */
- {"hi", "IN", "Asia/Jakarta"}, /* First day = 1, Minimum day = 1 */
- {"en", "GB", "Europe/London"}, /* First day = 2, Minimum day = 1 */
- {"en", "GB", "GMT"}, /* First day = 2, Minimum day = 1 */
- {"de", "DE", "Europe/Berlin"}, /* First day = 2, Minimum day = 4 */
- {"ar", "EG", "Africa/Cairo"}, /* First day = 7, Minimum day = 1 */
- };
+ {"en", "US", "US/Pacific"}, /* First day = 1, Minimum day = 1 */
+ {"en", "US", "America/Anchorage"}, /* First day = 1, Minimum day = 1 */
+ {"en", "TO", "Pacific/Tongatapu"}, /* First day = 1, Minimum day = 1 */
+ {"en", "MH", "Pacific/Majuro"}, /* First day = 1, Minimum day = 1 */
+ {"ja", "JP", "Asia/Tokyo"}, /* First day = 1, Minimum day = 1 */
+ {"iw", "IL", "Asia/Jerusalem"}, /* First day = 1, Minimum day = 1 */
+ {"hi", "IN", "Asia/Jakarta"}, /* First day = 1, Minimum day = 1 */
+ {"en", "GB", "Europe/London"}, /* First day = 2, Minimum day = 1 */
+ {"en", "GB", "GMT"}, /* First day = 2, Minimum day = 1 */
+ {"de", "DE", "Europe/Berlin"}, /* First day = 2, Minimum day = 4 */
+ {"ar", "EG", "Africa/Cairo"}}; /* First day = 7, Minimum day = 1 */
int[][] goldenData = {
- {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, -28800000, 0},
- {1, 1969, 11, 1, 5, 31, 365, 4, 5, 1, 11, 23, 0, 0, 0, -36000000, 0},
- {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 46800000, 0},
- {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 43200000, 0},
- {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 32400000, 0},
- {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 7200000, 0},
- {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 25200000, 0},
- {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 1, 1, 0, 0, 0, 3600000, 0},
- {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 0, 0},
- {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 3600000, 0},
- {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 7200000, 0},
- };
+ {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, -28800000, 0},
+ {1, 1969, 11, 1, 5, 31, 365, 4, 5, 1, 11, 23, 0, 0, 0, -36000000, 0},
+ {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 46800000, 0},
+ {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 43200000, 0},
+ {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 32400000, 0},
+ {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 7200000, 0},
+ {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 25200000, 0},
+ {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 1, 1, 0, 0, 0, 3600000, 0},
+ {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 0, 0},
+ {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 3600000, 0},
+ {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 7200000, 0}};
Locale savedLocale = Locale.getDefault();
TimeZone savedTimeZone = TimeZone.getDefault();
@@ -927,19 +986,18 @@
boolean err = false;
for (int i = 0; i < calendarFieldNames.length; ++i) {
if ((val = c.get(i)) != EPOCH_FIELDS[i]) {
- errln("Wrong value: " + val +
- " for field(" + calendarFieldNames[i] +
- "), expected: " + EPOCH_FIELDS[i]);
+ errln("Wrong value: " + val
+ + " for field(" + calendarFieldNames[i]
+ + "), expected: " + EPOCH_FIELDS[i]);
err = true;
}
}
if (err) {
- errln("Failed: \n\tDate=" + d + "\n\tTimeZone=" + z +
- "\n\tLocale=" + l + "\n\tCalendar=" + c);
+ errln("Failed: \n\tDate=" + d + "\n\tTimeZone=" + z
+ + "\n\tLocale=" + l + "\n\tCalendar=" + c);
}
}
- }
- finally {
+ } finally {
Locale.setDefault(savedLocale);
TimeZone.setDefault(savedTimeZone);
}
@@ -948,125 +1006,146 @@
// Verify that as you add days to the calendar (e.g., 24 day periods),
// the day of the week shifts in the expected pattern.
public void TestDOWProgression() {
- Calendar cal =
- new GregorianCalendar(1972, Calendar.OCTOBER, 26);
+ Calendar cal
+ = new GregorianCalendar(1972, OCTOBER, 26);
marchByDelta(cal, 24); // Last parameter must be != 0 modulo 7
}
// Supply a delta which is not a multiple of 7.
void marchByDelta(Calendar cal, int delta) {
- Calendar cur = (Calendar)cal.clone();
- int initialDOW = cur.get(Calendar.DAY_OF_WEEK);
+ Calendar cur = (Calendar) cal.clone();
+ int initialDOW = cur.get(DAY_OF_WEEK);
int DOW, newDOW = initialDOW;
do {
DOW = newDOW;
logln("DOW = " + DOW + " " + cur.getTime());
- cur.add(Calendar.DAY_OF_WEEK, delta);
- newDOW = cur.get(Calendar.DAY_OF_WEEK);
+ cur.add(DAY_OF_WEEK, delta);
+ newDOW = cur.get(DAY_OF_WEEK);
int expectedDOW = 1 + (DOW + delta - 1) % 7;
if (newDOW != expectedDOW) {
- errln("Day of week should be " + expectedDOW +
- " instead of " + newDOW + " on " + cur.getTime());
+ errln("Day of week should be " + expectedDOW
+ + " instead of " + newDOW + " on " + cur.getTime());
return;
}
- }
- while (newDOW != initialDOW);
+ } while (newDOW != initialDOW);
}
public void TestActualMinMax() {
- Calendar cal = new GregorianCalendar(1967, Calendar.MARCH, 10);
- cal.setFirstDayOfWeek(Calendar.SUNDAY);
+ Calendar cal = new GregorianCalendar(1967, MARCH, 10);
+ cal.setFirstDayOfWeek(SUNDAY);
cal.setMinimalDaysInFirstWeek(3);
- if (cal.getActualMinimum(Calendar.DAY_OF_MONTH) != 1)
- errln("Actual minimum date for 3/10/1967 should have been 1; got " +
- cal.getActualMinimum(Calendar.DAY_OF_MONTH));
- if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 31)
- errln("Actual maximum date for 3/10/1967 should have been 31; got " +
- cal.getActualMaximum(Calendar.DAY_OF_MONTH));
+ if (cal.getActualMinimum(DAY_OF_MONTH) != 1) {
+ errln("Actual minimum date for 3/10/1967 should have been 1; got "
+ + cal.getActualMinimum(DAY_OF_MONTH));
+ }
+ if (cal.getActualMaximum(DAY_OF_MONTH) != 31) {
+ errln("Actual maximum date for 3/10/1967 should have been 31; got "
+ + cal.getActualMaximum(DAY_OF_MONTH));
+ }
- cal.set(Calendar.MONTH, Calendar.FEBRUARY);
- if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 28)
- errln("Actual maximum date for 2/10/1967 should have been 28; got " +
- cal.getActualMaximum(Calendar.DAY_OF_MONTH));
- if (cal.getActualMaximum(Calendar.DAY_OF_YEAR) != 365)
- errln("Number of days in 1967 should have been 365; got " +
- cal.getActualMaximum(Calendar.DAY_OF_YEAR));
+ cal.set(MONTH, FEBRUARY);
+ if (cal.getActualMaximum(DAY_OF_MONTH) != 28) {
+ errln("Actual maximum date for 2/10/1967 should have been 28; got "
+ + cal.getActualMaximum(DAY_OF_MONTH));
+ }
+ if (cal.getActualMaximum(DAY_OF_YEAR) != 365) {
+ errln("Number of days in 1967 should have been 365; got "
+ + cal.getActualMaximum(DAY_OF_YEAR));
+ }
- cal.set(Calendar.YEAR, 1968);
- if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 29)
- errln("Actual maximum date for 2/10/1968 should have been 29; got " +
- cal.getActualMaximum(Calendar.DAY_OF_MONTH));
- if (cal.getActualMaximum(Calendar.DAY_OF_YEAR) != 366)
- errln("Number of days in 1968 should have been 366; got " +
- cal.getActualMaximum(Calendar.DAY_OF_YEAR));
+ cal.set(YEAR, 1968);
+ if (cal.getActualMaximum(DAY_OF_MONTH) != 29) {
+ errln("Actual maximum date for 2/10/1968 should have been 29; got "
+ + cal.getActualMaximum(DAY_OF_MONTH));
+ }
+ if (cal.getActualMaximum(DAY_OF_YEAR) != 366) {
+ errln("Number of days in 1968 should have been 366; got "
+ + cal.getActualMaximum(DAY_OF_YEAR));
+ }
// Using week settings of SUNDAY/3 (see above)
- if (cal.getActualMaximum(Calendar.WEEK_OF_YEAR) != 52)
- errln("Number of weeks in 1968 should have been 52; got " +
- cal.getActualMaximum(Calendar.WEEK_OF_YEAR));
+ if (cal.getActualMaximum(WEEK_OF_YEAR) != 52) {
+ errln("Number of weeks in 1968 should have been 52; got "
+ + cal.getActualMaximum(WEEK_OF_YEAR));
+ }
- cal.set(Calendar.YEAR, 1976);
+ cal.set(YEAR, 1976);
// Using week settings of SUNDAY/3 (see above)
- if (cal.getActualMaximum(Calendar.WEEK_OF_YEAR) != 53)
- errln("Number of weeks in 1976 should have been 53; got " +
- cal.getActualMaximum(Calendar.WEEK_OF_YEAR));
+ if (cal.getActualMaximum(WEEK_OF_YEAR) != 53) {
+ errln("Number of weeks in 1976 should have been 53; got "
+ + cal.getActualMaximum(WEEK_OF_YEAR));
+ }
}
public void TestRoll() {
- Calendar cal = new GregorianCalendar(1997, Calendar.JANUARY, 31);
+ Calendar cal = new GregorianCalendar(1997, JANUARY, 31);
- int[] dayValues = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31 };
+ int[] dayValues = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31};
for (int i = 0; i < dayValues.length; i++) {
- Calendar cal2 = (Calendar)cal.clone();
- cal2.roll(Calendar.MONTH, i);
- if (cal2.get(Calendar.DAY_OF_MONTH) != dayValues[i])
+ Calendar cal2 = (Calendar) cal.clone();
+ cal2.roll(MONTH, i);
+ if (cal2.get(DAY_OF_MONTH) != dayValues[i]) {
errln("Rolling the month in 1/31/1997 up by " + i + " should have yielded "
- + ((i + 1) % 12) + "/" + dayValues[i] + "/1997, but actually yielded "
- + ((i + 1) % 12) + "/" + cal2.get(Calendar.DAY_OF_MONTH) + "/1997.");
+ + ((i + 1) % 12) + "/" + dayValues[i] + "/1997, but actually yielded "
+ + ((i + 1) % 12) + "/" + cal2.get(DAY_OF_MONTH) + "/1997.");
+ }
}
- cal.set(1996, Calendar.FEBRUARY, 29);
+ cal.set(1996, FEBRUARY, 29);
- int[] monthValues = { 1, 2, 2, 2, 1, 2, 2, 2, 1, 2 };
- int[] dayValues2 = { 29, 1, 1, 1, 29, 1, 1, 1, 29, 1 };
+ int[] monthValues = {1, 2, 2, 2, 1, 2, 2, 2, 1, 2};
+ int[] dayValues2 = {29, 1, 1, 1, 29, 1, 1, 1, 29, 1};
for (int i = 0; i < dayValues2.length; i++) {
- Calendar cal2 = (Calendar)cal.clone();
- cal2.roll(Calendar.YEAR, i);
- if (cal2.get(Calendar.DAY_OF_MONTH) != dayValues2[i] || cal2.get(Calendar.MONTH)
- != monthValues[i])
+ Calendar cal2 = (Calendar) cal.clone();
+ cal2.roll(YEAR, i);
+ if (cal2.get(DAY_OF_MONTH) != dayValues2[i] || cal2.get(MONTH)
+ != monthValues[i]) {
errln("Rolling the year in 2/29/1996 up by " + i + " should have yielded "
- + (monthValues[i] + 1) + "/" + dayValues2[i] + "/"
- + (1996 + i) + ", but actually yielded "
- + (cal2.get(Calendar.MONTH) + 1) + "/" +
- cal2.get(Calendar.DAY_OF_MONTH) + "/" + (1996 + i) + ".");
+ + (monthValues[i] + 1) + "/" + dayValues2[i] + "/"
+ + (1996 + i) + ", but actually yielded "
+ + (cal2.get(MONTH) + 1) + "/"
+ + cal2.get(DAY_OF_MONTH) + "/" + (1996 + i) + ".");
+ }
}
// Test rolling hour of day
- cal.set(Calendar.HOUR_OF_DAY, 0);
- cal.roll(Calendar.HOUR_OF_DAY, -2);
- int f = cal.get(Calendar.HOUR_OF_DAY);
- if (f != 22) errln("Rolling HOUR_OF_DAY=0 delta=-2 gave " + f + " Wanted 22");
- cal.roll(Calendar.HOUR_OF_DAY, 5);
- f = cal.get(Calendar.HOUR_OF_DAY);
- if (f != 3) errln("Rolling HOUR_OF_DAY=22 delta=5 gave " + f + " Wanted 3");
- cal.roll(Calendar.HOUR_OF_DAY, 21);
- f = cal.get(Calendar.HOUR_OF_DAY);
- if (f != 0) errln("Rolling HOUR_OF_DAY=3 delta=21 gave " + f + " Wanted 0");
+ cal.set(HOUR_OF_DAY, 0);
+ cal.roll(HOUR_OF_DAY, -2);
+ int f = cal.get(HOUR_OF_DAY);
+ if (f != 22) {
+ errln("Rolling HOUR_OF_DAY=0 delta=-2 gave " + f + " Wanted 22");
+ }
+ cal.roll(HOUR_OF_DAY, 5);
+ f = cal.get(HOUR_OF_DAY);
+ if (f != 3) {
+ errln("Rolling HOUR_OF_DAY=22 delta=5 gave " + f + " Wanted 3");
+ }
+ cal.roll(HOUR_OF_DAY, 21);
+ f = cal.get(HOUR_OF_DAY);
+ if (f != 0) {
+ errln("Rolling HOUR_OF_DAY=3 delta=21 gave " + f + " Wanted 0");
+ }
// Test rolling hour
- cal.set(Calendar.HOUR_OF_DAY, 0);
- cal.roll(Calendar.HOUR, -2);
- f = cal.get(Calendar.HOUR);
- if (f != 10) errln("Rolling HOUR=0 delta=-2 gave " + f + " Wanted 10");
- cal.roll(Calendar.HOUR, 5);
- f = cal.get(Calendar.HOUR);
- if (f != 3) errln("Rolling HOUR=10 delta=5 gave " + f + " Wanted 3");
- cal.roll(Calendar.HOUR, 9);
- f = cal.get(Calendar.HOUR);
- if (f != 0) errln("Rolling HOUR=3 delta=9 gave " + f + " Wanted 0");
+ cal.set(HOUR_OF_DAY, 0);
+ cal.roll(HOUR, -2);
+ f = cal.get(HOUR);
+ if (f != 10) {
+ errln("Rolling HOUR=0 delta=-2 gave " + f + " Wanted 10");
+ }
+ cal.roll(HOUR, 5);
+ f = cal.get(HOUR);
+ if (f != 3) {
+ errln("Rolling HOUR=10 delta=5 gave " + f + " Wanted 3");
+ }
+ cal.roll(HOUR, 9);
+ f = cal.get(HOUR);
+ if (f != 0) {
+ errln("Rolling HOUR=3 delta=9 gave " + f + " Wanted 0");
+ }
}
/*
@@ -1081,19 +1160,18 @@
TimeZone.setDefault(TimeZone.getTimeZone("PST"));
Calendar cal = Calendar.getInstance();
- cal.set(Calendar.YEAR, 2001);
- cal.set(Calendar.MONTH, Calendar.OCTOBER);
- cal.set(Calendar.WEEK_OF_YEAR, 4);
- cal.set(Calendar.DAY_OF_WEEK, 2);
+ cal.set(YEAR, 2001);
+ cal.set(MONTH, OCTOBER);
+ cal.set(WEEK_OF_YEAR, 4);
+ cal.set(DAY_OF_WEEK, 2);
- if (cal.get(Calendar.YEAR) != 2001 ||
- cal.get(Calendar.MONTH) != Calendar.JANUARY ||
- cal.get(Calendar.DATE) != 22 ||
- cal.get(Calendar.DAY_OF_WEEK) != Calendar.MONDAY) {
+ if (cal.get(YEAR) != 2001
+ || cal.get(MONTH) != JANUARY
+ || cal.get(DATE) != 22
+ || cal.get(DAY_OF_WEEK) != MONDAY) {
errln("Failed : got " + cal.getTime() + ", expected Mon Jan 22, 2001");
}
- }
- finally {
+ } finally {
Locale.setDefault(savedLocale);
TimeZone.setDefault(savedTimeZone);
}
--- a/jdk/test/java/util/Calendar/CalendarTypeTest.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/CalendarTypeTest.java Thu Nov 17 11:40:50 2016 +0530
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2016, 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
@@ -27,9 +27,13 @@
* @summary Unit test for calendar types
*/
-import java.util.*;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.Set;
public class CalendarTypeTest {
+
// Calendar types supported in JRE
static Locale[] locales = new Locale[] {
Locale.US,
@@ -37,23 +41,20 @@
new Locale("th", "TH"),
Locale.forLanguageTag("en-US-u-ca-buddhist"),
new Locale("ja", "JP", "JP"),
- Locale.forLanguageTag("en-US-u-ca-japanese"),
- };
+ Locale.forLanguageTag("en-US-u-ca-japanese")};
static final String[] TYPES = new String[] {
"gregory",
"buddhist",
- "japanese",
- };
+ "japanese"};
static final String[] ALIASES = new String[] {
"gregorian",
- "iso8601",
- };
+ "iso8601"};
public static void main(String[] args) {
for (int i = 0; i < locales.length; i++) {
Calendar cal = Calendar.getInstance(locales[i]);
String type = cal.getCalendarType();
- checkValue("bad calendar type", type, TYPES[i/2]);
+ checkValue("bad calendar type", type, TYPES[i / 2]);
}
GregorianCalendar gcal = new GregorianCalendar();
@@ -88,10 +89,13 @@
}
}
+ @SuppressWarnings("serial")
private static class Gregorian extends GregorianCalendar {
}
+ @SuppressWarnings("serial")
private static class Koyomi extends Calendar {
+
@Override
protected void computeTime() {
throw new UnsupportedOperationException("Not supported yet.");
--- a/jdk/test/java/util/Calendar/FieldStateTest.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/FieldStateTest.java Thu Nov 17 11:40:50 2016 +0530
@@ -144,8 +144,11 @@
}
logln("Set day of week to SUNDAY and date to 2003/10/31. "
- + "Then, getTime and set week of year to 43.");
- cal.setTime(new Date(2003-1990, OCTOBER, 31));
+ + "Then, getTime and set week of year to 43.");
+
+ @SuppressWarnings("deprecation")
+ Date d = new Date(2003 - 1990, OCTOBER, 31);
+ cal.setTime(d);
cal.set(DAY_OF_WEEK, SUNDAY);
cal.set(2003, OCTOBER, 31); // 2003/10/31 is Friday.
cal.set(ZONE_OFFSET, 0);
@@ -166,8 +169,8 @@
* 4916815: REGRESSION: Problem with java.util.Calendar VM 1.4.2-b28
*/
public void Test4916815() {
- logln("Set date to 2003/9/26 (Fri). Roll to Aug and back to Sep. "+
- "Set dayofweek to Sunday which should be 2003/9/21.");
+ logln("Set date to 2003/9/26 (Fri). Roll to Aug and back to Sep. "
+ + "Set dayofweek to Sunday which should be 2003/9/21.");
Koyomi cal = new Koyomi();
cal.clear();
// 2003/9/26 (Fri)
@@ -192,17 +195,17 @@
cal.clear();
cal.set(YEAR, 2004);
cal.set(WEEK_OF_YEAR, 1);
- checkDate(cal, SUNDAY, 2003, DECEMBER, 28);
- checkDate(cal, MONDAY, 2003, DECEMBER, 29);
- checkDate(cal, TUESDAY, 2003, DECEMBER, 30);
+ checkDate(cal, SUNDAY, 2003, DECEMBER, 28);
+ checkDate(cal, MONDAY, 2003, DECEMBER, 29);
+ checkDate(cal, TUESDAY, 2003, DECEMBER, 30);
checkDate(cal, WEDNESDAY, 2003, DECEMBER, 31);
- checkDate(cal, THURSDAY, 2004, JANUARY, 1);
- checkDate(cal, FRIDAY, 2004, JANUARY, 2);
- checkDate(cal, SATURDAY, 2004, JANUARY, 3);
+ checkDate(cal, THURSDAY, 2004, JANUARY, 1);
+ checkDate(cal, FRIDAY, 2004, JANUARY, 2);
+ checkDate(cal, SATURDAY, 2004, JANUARY, 3);
}
private void checkDate(Koyomi cal, int dayOfWeek,
- int expectedYear, int expectedMonth, int expectedDayOfMonth) {
+ int expectedYear, int expectedMonth, int expectedDayOfMonth) {
cal.set(DAY_OF_WEEK, dayOfWeek);
cal.getTime();
if (!cal.checkInternalDate(expectedYear, expectedMonth, expectedDayOfMonth, dayOfWeek)) {
--- a/jdk/test/java/util/Calendar/GregorianCutoverTest.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/GregorianCutoverTest.java Thu Nov 17 11:40:50 2016 +0530
@@ -76,7 +76,9 @@
checkContinuity(cal, WEEK_OF_YEAR);
// Use large date (year >= 50000)
- cal.setGregorianChange(new Date(50000-1900, JANUARY, 20));
+ @SuppressWarnings("deprecation")
+ Date d = new Date(50000 - 1900, JANUARY, 20);
+ cal.setGregorianChange(d);
cal.set(49998, JANUARY, 1);
checkContinuity(cal, DAY_OF_YEAR);
checkContinuity(cal, WEEK_OF_YEAR);
@@ -124,7 +126,9 @@
// should handle the gap between 1969/12/22 (Julian) to 1970/1/5 (Gregorian)
logln("Cutover date is 1970/1/5");
- cal.setGregorianChange(new Date(1970-1900, JANUARY, 5));
+ @SuppressWarnings("deprecation")
+ Date d1 = new Date(1970 - 1900, JANUARY, 5);
+ cal.setGregorianChange(d1);
cal.set(ERA, AD);
cal.set(YEAR, 1970);
logln(" Set DAY_OF_YEAR to the 28th day of 1970");
@@ -203,16 +207,17 @@
public void Test4928615() {
Koyomi cal = new Koyomi();
logln("Today is 2003/10/1 Gregorian.");
- Date x = new Date(2003-1900, 10-1, 1);
+ @SuppressWarnings("deprecation")
+ Date x = new Date(2003 - 1900, 10 - 1, 1);
cal.setTime(x);
logln(" Changing the cutover date to yesterday...");
- cal.setGregorianChange(new Date(x.getTime() - (24*3600*1000)));
+ cal.setGregorianChange(new Date(x.getTime() - (24 * 3600 * 1000)));
if (!cal.checkDate(2003, OCTOBER, 1)) {
errln(" " + cal.getMessage());
}
logln(" Changing the cutover date to tomorrow...");
- cal.setGregorianChange(new Date(x.getTime() + (24*3600*1000)));
+ cal.setGregorianChange(new Date(x.getTime() + (24 * 3600 * 1000)));
if (!cal.checkDate(2003, SEPTEMBER, 18)) {
errln(" " + cal.getMessage());
}
@@ -225,11 +230,11 @@
Koyomi cal = new Koyomi();
Koyomi cal2 = (Koyomi) cal.clone();
logln("getLeastMaximum should handle cutover year.\n"
- +" default cutover date");
- if (!cal.checkLeastMaximum(DAY_OF_YEAR, 365-10)) {
+ + " default cutover date");
+ if (!cal.checkLeastMaximum(DAY_OF_YEAR, 365 - 10)) {
errln(" " + cal.getMessage());
}
- if (!cal.checkLeastMaximum(WEEK_OF_YEAR, 52-((10+6)/7))) {
+ if (!cal.checkLeastMaximum(WEEK_OF_YEAR, 52 - ((10 + 6) / 7))) {
errln(" " + cal.getMessage());
}
// Corrected for 4956232
@@ -261,7 +266,9 @@
cal = new Koyomi();
logln("Change the cutover date to 1970/1/5.");
- cal.setGregorianChange(new Date(1970-1900, 0, 5));
+ @SuppressWarnings("deprecation")
+ Date d = new Date(1970 - 1900, 0, 5);
+ cal.setGregorianChange(d);
if (!cal.checkLeastMaximum(DAY_OF_YEAR, 356)) {
errln(" " + cal.getMessage());
}
@@ -287,15 +294,15 @@
int hour = 13865672;
Koyomi gc1 = new Koyomi();
gc1.clear();
- gc1.set(1, gc1.JANUARY, 1, 0, 0, 0);
- gc1.set(gc1.HOUR_OF_DAY, hour);
- if (!gc1.checkDate(1582, gc1.OCTOBER, 4)) {
+ gc1.set(1, JANUARY, 1, 0, 0, 0);
+ gc1.set(HOUR_OF_DAY, hour);
+ if (!gc1.checkDate(1582, OCTOBER, 4)) {
errln("test case 1: " + gc1.getMessage());
}
gc1.clear();
- gc1.set(1, gc1.JANUARY, 1, 0, 0, 0);
- gc1.set(gc1.HOUR_OF_DAY, hour + 24);
- if (!gc1.checkDate(1582, gc1.OCTOBER, 15)) {
+ gc1.set(1, JANUARY, 1, 0, 0, 0);
+ gc1.set(HOUR_OF_DAY, hour + 24);
+ if (!gc1.checkDate(1582, OCTOBER, 15)) {
errln("test case 2: " + gc1.getMessage());
}
}
--- a/jdk/test/java/util/Calendar/JavatimeTest.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/JavatimeTest.java Thu Nov 17 11:40:50 2016 +0530
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2016, 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
@@ -28,16 +28,16 @@
* @key randomness
*/
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Random;
import java.util.TimeZone;
-import java.time.Instant;
-import java.time.LocalDateTime;
-import java.time.ZonedDateTime;
-import java.time.ZoneId;
-import java.time.ZoneOffset;
public class JavatimeTest {
@@ -46,10 +46,11 @@
public static void main(String[] args) throws Throwable {
int N = 10000;
+ @SuppressWarnings("deprecation")
long t1970 = new java.util.Date(70, 0, 01).getTime();
Random r = new Random();
for (int i = 0; i < N; i++) {
- int days = r.nextInt(50) * 365 + r.nextInt(365);
+ int days = r.nextInt(50) * 365 + r.nextInt(365);
long secs = t1970 + days * 86400 + r.nextInt(86400);
int nanos = r.nextInt(NANOS_PER_SECOND);
int nanos_ms = nanos / 1000000 * 1000000; // millis precision
@@ -61,15 +62,15 @@
///////////// java.util.Date /////////////////////////
Date jud = new java.util.Date(millis);
Instant inst0 = jud.toInstant();
- if (jud.getTime() != inst0.toEpochMilli() ||
- !jud.equals(Date.from(inst0))) {
+ if (jud.getTime() != inst0.toEpochMilli()
+ || !jud.equals(Date.from(inst0))) {
System.out.printf("ms: %16d ns: %10d ldt:[%s]%n", millis, nanos, ldt);
throw new RuntimeException("FAILED: j.u.d -> instant -> j.u.d");
}
// roundtrip only with millis precision
Date jud0 = Date.from(inst_ms);
- if (jud0.getTime() != inst_ms.toEpochMilli() ||
- !inst_ms.equals(jud0.toInstant())) {
+ if (jud0.getTime() != inst_ms.toEpochMilli()
+ || !inst_ms.equals(jud0.toInstant())) {
System.out.printf("ms: %16d ns: %10d ldt:[%s]%n", millis, nanos, ldt);
throw new RuntimeException("FAILED: instant -> j.u.d -> instant");
}
@@ -82,8 +83,8 @@
cal.setMinimalDaysInFirstWeek(4);
cal.setTimeInMillis(millis);
ZonedDateTime zdt0 = cal.toZonedDateTime();
- if (cal.getTimeInMillis() != zdt0.toInstant().toEpochMilli() ||
- !cal.equals(GregorianCalendar.from(zdt0))) {
+ if (cal.getTimeInMillis() != zdt0.toInstant().toEpochMilli()
+ || !cal.equals(GregorianCalendar.from(zdt0))) {
System.out.println("cal:" + cal);
System.out.println("zdt:" + zdt0);
System.out.println("calNew:" + GregorianCalendar.from(zdt0));
@@ -97,8 +98,8 @@
}
ZonedDateTime zdt = ZonedDateTime.of(ldt_ms, ZoneId.systemDefault());
GregorianCalendar cal0 = GregorianCalendar.from(zdt);
- if (zdt.toInstant().toEpochMilli() != cal0.getTimeInMillis() ||
- !zdt.equals(GregorianCalendar.from(zdt).toZonedDateTime())) {
+ if (zdt.toInstant().toEpochMilli() != cal0.getTimeInMillis()
+ || !zdt.equals(GregorianCalendar.from(zdt).toZonedDateTime())) {
System.out.printf("ms: %16d ns: %10d ldt:[%s]%n", millis, nanos, ldt);
throw new RuntimeException("FAILED: zdt -> gcal -> zdt");
}
@@ -107,12 +108,12 @@
///////////// java.util.TimeZone /////////////////////////
for (String zidStr : TimeZone.getAvailableIDs()) {
// TBD: tzdt intergration
- if (zidStr.startsWith("SystemV") ||
- zidStr.contains("Riyadh8") ||
- zidStr.equals("US/Pacific-New") ||
- zidStr.equals("EST") ||
- zidStr.equals("HST") ||
- zidStr.equals("MST")) {
+ if (zidStr.startsWith("SystemV")
+ || zidStr.contains("Riyadh8")
+ || zidStr.equals("US/Pacific-New")
+ || zidStr.equals("EST")
+ || zidStr.equals("HST")
+ || zidStr.equals("MST")) {
continue;
}
ZoneId zid = ZoneId.of(zidStr, ZoneId.SHORT_IDS);
@@ -121,9 +122,9 @@
}
TimeZone tz = TimeZone.getTimeZone(zidStr);
// no round-trip for alias and "GMT"
- if (!tz.equals(TimeZone.getTimeZone(tz.toZoneId())) &&
- !ZoneId.SHORT_IDS.containsKey(zidStr) &&
- !zidStr.startsWith("GMT")) {
+ if (!tz.equals(TimeZone.getTimeZone(tz.toZoneId()))
+ && !ZoneId.SHORT_IDS.containsKey(zidStr)
+ && !zidStr.startsWith("GMT")) {
throw new RuntimeException("FAILED: tz -> zid -> tz :" + zidStr);
}
}
--- a/jdk/test/java/util/Calendar/Koyomi.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/Koyomi.java Thu Nov 17 11:40:50 2016 +0530
@@ -21,8 +21,6 @@
* questions.
*/
-import static java.util.Calendar.*;
-
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.TimeZone;
@@ -30,7 +28,9 @@
/**
* GregorianCalendar subclass for testing.
*/
+@SuppressWarnings("serial")
public class Koyomi extends GregorianCalendar {
+
static final String[] FIELD_NAMES = {
"ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH", "DAY_OF_MONTH",
"DAY_OF_YEAR", "DAY_OF_WEEK", "DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR",
@@ -78,7 +78,7 @@
StringBuilder sb = new StringBuilder();
sb.append(internalGet(ERA) == 0 ? "BCE " : "");
sb.append(internalGet(YEAR)).append('-');
- sb.append(internalGet(MONTH)+1).append('-');
+ sb.append(internalGet(MONTH) + 1).append('-');
sb.append(internalGet(DAY_OF_MONTH));
return sb.toString();
}
@@ -98,7 +98,7 @@
sb.append(ms);
int offset = internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET);
offset /= 60000;
- offset = (offset/60) * 100 + (offset%60);
+ offset = (offset / 60) * 100 + (offset % 60);
if (offset >= 0) {
sb.append('+');
} else {
@@ -187,8 +187,8 @@
boolean checkActualMaximum(int field, int expectedValue) {
int val;
if ((val = getActualMaximum(field)) != expectedValue) {
- appendMessage("getActualMaximum("+FIELD_NAMES[field]+"): got " + val
- + " expected " + expectedValue);
+ appendMessage("getActualMaximum(" + FIELD_NAMES[field] + "): got " + val
+ + " expected " + expectedValue);
}
return getStatus();
}
@@ -196,8 +196,8 @@
boolean checkLeastMaximum(int field, int expectedValue) {
int val;
if ((val = getLeastMaximum(field)) != expectedValue) {
- appendMessage("getLeastMaximum("+FIELD_NAMES[field]+"): got " + val
- + " expected " + expectedValue);
+ appendMessage("getLeastMaximum(" + FIELD_NAMES[field] + "): got " + val
+ + " expected " + expectedValue);
}
return getStatus();
}
@@ -205,8 +205,8 @@
boolean checkActualMinimum(int field, int expectedValue) {
int val;
if ((val = getActualMinimum(field)) != expectedValue) {
- appendMessage("getActualMinimum("+FIELD_NAMES[field]+"): got " + val
- + " expected " + expectedValue);
+ appendMessage("getActualMinimum(" + FIELD_NAMES[field] + "): got " + val
+ + " expected " + expectedValue);
}
return getStatus();
}
@@ -214,8 +214,8 @@
boolean checkGreatestMinimum(int field, int expectedValue) {
int val;
if ((val = getGreatestMinimum(field)) != expectedValue) {
- appendMessage("getGreatestMinimum("+FIELD_NAMES[field]+"): got " + val
- + " expected " + expectedValue);
+ appendMessage("getGreatestMinimum(" + FIELD_NAMES[field] + "): got " + val
+ + " expected " + expectedValue);
}
return getStatus();
}
@@ -238,7 +238,7 @@
}
boolean checkDateTime(int year, int month, int dayOfMonth,
- int hourOfDay, int minute, int second, int ms) {
+ int hourOfDay, int minute, int second, int ms) {
initTest();
checkFieldValue(YEAR, year);
checkFieldValue(MONTH, month);
@@ -270,8 +270,8 @@
boolean checkFieldValue(int field, int expectedValue) {
int val;
if ((val = get(field)) != expectedValue) {
- appendMessage("get(" + FIELD_NAMES[field] + "): got " + val +
- ", expected " + expectedValue + "; ");
+ appendMessage("get(" + FIELD_NAMES[field] + "): got " + val
+ + ", expected " + expectedValue + "; ");
return false;
}
return true;
@@ -280,8 +280,8 @@
boolean checkInternalFieldValue(int field, int expectedValue) {
int val;
if ((val = internalGet(field)) != expectedValue) {
- appendMessage("internalGet(" + FIELD_NAMES[field] + "): got " + val +
- ", expected " + expectedValue + "; ");
+ appendMessage("internalGet(" + FIELD_NAMES[field] + "): got " + val
+ + ", expected " + expectedValue + "; ");
return false;
}
return true;
--- a/jdk/test/java/util/Calendar/NonLenientTest.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/NonLenientTest.java Thu Nov 17 11:40:50 2016 +0530
@@ -28,7 +28,10 @@
* @library /java/text/testlib
*/
-import java.util.*;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.TimeZone;
import static java.util.Calendar.*;
@@ -129,7 +132,6 @@
validate(cal, "6th Sunday in Jan 2003");
}
-
/**
* 4726030: GregorianCalendar doesn't check invalid dates in non-lenient
*/
@@ -146,34 +148,34 @@
*/
public void Test4147269() {
Koyomi calendar = getNonLenient();
- Date date = (new GregorianCalendar(1996,0,3)).getTime();
+ Date date = (new GregorianCalendar(1996, 0, 3)).getTime();
- for (int field = 0; field < Calendar.FIELD_COUNT; field++) {
+ for (int field = 0; field < FIELD_COUNT; field++) {
calendar.setTime(date);
int max = calendar.getActualMaximum(field);
- int value = max+1;
+ int value = max + 1;
calendar.set(field, value);
try {
calendar.computeTime(); // call method under test
- errln("Test failed with field " + calendar.getFieldName(field)
- + "\n\tdate before: " + date
- + "\n\tdate after: " + calendar.getTime()
- + "\n\tvalue: " + value + " (max = " + max +")");
+ errln("Test failed with field " + Koyomi.getFieldName(field)
+ + "\n\tdate before: " + date
+ + "\n\tdate after: " + calendar.getTime()
+ + "\n\tvalue: " + value + " (max = " + max + ")");
} catch (IllegalArgumentException e) {
}
}
- for (int field = 0; field < Calendar.FIELD_COUNT; field++) {
+ for (int field = 0; field < FIELD_COUNT; field++) {
calendar.setTime(date);
int min = calendar.getActualMinimum(field);
- int value = min-1;
+ int value = min - 1;
calendar.set(field, value);
try {
calendar.computeTime(); // call method under test
- errln("Test failed with field " + calendar.getFieldName(field)
- + "\n\tdate before: " + date
- + "\n\tdate after: " + calendar.getTime()
- + "\n\tvalue: " + value + " (min = " + min +")");
+ errln("Test failed with field " + Koyomi.getFieldName(field)
+ + "\n\tdate before: " + date
+ + "\n\tdate after: " + calendar.getTime()
+ + "\n\tvalue: " + value + " (min = " + min + ")");
} catch (IllegalArgumentException e) {
}
}
@@ -194,17 +196,17 @@
// In non-lenient, calendar field values that have beeb set by
// user shouldn't be modified.
int[] afterFields = cal.getFields();
- for (int i = 0; i < Calendar.FIELD_COUNT; i++) {
+ for (int i = 0; i < FIELD_COUNT; i++) {
if (cal.isSet(i) && originalFields[i] != afterFields[i]) {
- errln(" complete() modified fields[" + cal.getFieldName(i) + "] got "
- + afterFields[i] + ", expected " + originalFields[i]);
+ errln(" complete() modified fields[" + Koyomi.getFieldName(i) + "] got "
+ + afterFields[i] + ", expected " + originalFields[i]);
}
}
// In non-lenient, set state of fields shouldn't be modified.
int afterSetFields = cal.getSetStateFields();
if (setFields != afterSetFields) {
errln(" complate() modified set states: before 0x" + toHex(setFields)
- + ", after 0x"+ toHex(afterSetFields));
+ + ", after 0x" + toHex(afterSetFields));
}
}
--- a/jdk/test/java/util/Calendar/ZoneOffsets.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/ZoneOffsets.java Thu Nov 17 11:40:50 2016 +0530
@@ -28,12 +28,20 @@
* taken into account for time calculations.
*/
-import java.util.*;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.TimeZone;
+
import static java.util.GregorianCalendar.*;
public class ZoneOffsets {
+
// This TimeZone always returns the dstOffset value.
+ @SuppressWarnings("serial")
private static class TestTimeZone extends TimeZone {
+
private int gmtOffset;
private int dstOffset;
@@ -44,7 +52,7 @@
}
public int getOffset(int era, int year, int month, int day,
- int dayOfWeek, int milliseconds) {
+ int dayOfWeek, int milliseconds) {
return gmtOffset + dstOffset;
}
@@ -80,22 +88,20 @@
private static Locale[] locales = {
Locale.getDefault(),
new Locale("th", "TH"),
- new Locale("ja", "JP", "JP"),
- };
+ new Locale("ja", "JP", "JP")};
private static final int HOUR = 60 * 60 * 1000;
private static int[][] offsets = {
- { 0, 0 },
- { 0, HOUR },
- { 0, 2 * HOUR },
- { -8 * HOUR, 0 },
- { -8 * HOUR, HOUR },
- { -8 * HOUR, 2 * HOUR },
- { 9 * HOUR, 0 },
- { 9 * HOUR, HOUR },
- { 9 * HOUR, 2 * HOUR },
- };
+ {0, 0},
+ {0, HOUR},
+ {0, 2 * HOUR},
+ {-8 * HOUR, 0},
+ {-8 * HOUR, HOUR},
+ {-8 * HOUR, 2 * HOUR},
+ {9 * HOUR, 0},
+ {9 * HOUR, HOUR},
+ {9 * HOUR, 2 * HOUR}};
public static void main(String[] args) {
for (int l = 0; l < locales.length; l++) {
@@ -121,17 +127,17 @@
private static void test(Locale loc, int gmtOffset, int dstOffset) {
TimeZone tz1 = new TestTimeZone(gmtOffset,
- "GMT" + (gmtOffset/HOUR) + "." + (dstOffset/HOUR),
- dstOffset);
+ "GMT" + (gmtOffset / HOUR) + "." + (dstOffset / HOUR),
+ dstOffset);
int someDifferentOffset = gmtOffset + 2 * HOUR;
TimeZone tz2 = new TestTimeZone(someDifferentOffset,
- "GMT"+ (someDifferentOffset/HOUR) + "." + (dstOffset/HOUR),
- dstOffset);
+ "GMT" + (someDifferentOffset / HOUR) + "." + (dstOffset / HOUR),
+ dstOffset);
int someDifferentDSTOffset = dstOffset == 2 * HOUR ? HOUR : dstOffset + HOUR;
TimeZone tz3 = new TestTimeZone(gmtOffset,
- "GMT"+ (gmtOffset/HOUR) + "." + (someDifferentDSTOffset/HOUR),
- someDifferentDSTOffset);
+ "GMT" + (gmtOffset / HOUR) + "." + (someDifferentDSTOffset / HOUR),
+ someDifferentDSTOffset);
// cal1 is the base line.
Calendar cal1 = Calendar.getInstance(tz1, loc);
@@ -225,7 +231,7 @@
private static void error(String msg, Locale loc, Calendar cal2, int gmtOffset, int dstOffset, long t1) {
System.err.println(cal2);
throw new RuntimeException(msg + ": Locale=" + loc
- + ", gmtOffset=" + gmtOffset + ", dstOffset=" + dstOffset
- + ", cal1 time=" + t1 + ", cal2 time=" + cal2.getTime().getTime());
+ + ", gmtOffset=" + gmtOffset + ", dstOffset=" + dstOffset
+ + ", cal1 time=" + t1 + ", cal2 time=" + cal2.getTime().getTime());
}
}
--- a/jdk/test/java/util/Calendar/bug4372743.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/bug4372743.java Thu Nov 17 11:40:50 2016 +0530
@@ -28,9 +28,8 @@
* @library /java/text/testlib
*/
-import java.io.*;
-import java.util.*;
-import java.text.*;
+import java.util.GregorianCalendar;
+import java.util.TimeZone;
import static java.util.GregorianCalendar.*;
@@ -41,51 +40,50 @@
}
private int[][] data = {
- {AD, 2, MARCH},
- {AD, 2, FEBRUARY},
- {AD, 2, JANUARY},
- {AD, 1, DECEMBER},
- {AD, 1, NOVEMBER},
- {AD, 1, OCTOBER},
- {AD, 1, SEPTEMBER},
- {AD, 1, AUGUST},
- {AD, 1, JULY},
- {AD, 1, JUNE},
- {AD, 1, MAY},
- {AD, 1, APRIL},
- {AD, 1, MARCH},
- {AD, 1, FEBRUARY},
- {AD, 1, JANUARY},
- {BC, 1, DECEMBER},
- {BC, 1, NOVEMBER},
- {BC, 1, OCTOBER},
- {BC, 1, SEPTEMBER},
- {BC, 1, AUGUST},
- {BC, 1, JULY},
- {BC, 1, JUNE},
- {BC, 1, MAY},
- {BC, 1, APRIL},
- {BC, 1, MARCH},
- {BC, 1, FEBRUARY},
- {BC, 1, JANUARY},
- {BC, 2, DECEMBER},
- {BC, 2, NOVEMBER},
- {BC, 2, OCTOBER},
- };
+ {AD, 2, MARCH},
+ {AD, 2, FEBRUARY},
+ {AD, 2, JANUARY},
+ {AD, 1, DECEMBER},
+ {AD, 1, NOVEMBER},
+ {AD, 1, OCTOBER},
+ {AD, 1, SEPTEMBER},
+ {AD, 1, AUGUST},
+ {AD, 1, JULY},
+ {AD, 1, JUNE},
+ {AD, 1, MAY},
+ {AD, 1, APRIL},
+ {AD, 1, MARCH},
+ {AD, 1, FEBRUARY},
+ {AD, 1, JANUARY},
+ {BC, 1, DECEMBER},
+ {BC, 1, NOVEMBER},
+ {BC, 1, OCTOBER},
+ {BC, 1, SEPTEMBER},
+ {BC, 1, AUGUST},
+ {BC, 1, JULY},
+ {BC, 1, JUNE},
+ {BC, 1, MAY},
+ {BC, 1, APRIL},
+ {BC, 1, MARCH},
+ {BC, 1, FEBRUARY},
+ {BC, 1, JANUARY},
+ {BC, 2, DECEMBER},
+ {BC, 2, NOVEMBER},
+ {BC, 2, OCTOBER}};
private int tablesize = data.length;
private void check(GregorianCalendar gc, int index) {
if (gc.get(ERA) != data[index][ERA]) {
- errln("Invalid era :" + gc.get(ERA) +
- ", expected :" + data[index][ERA]);
+ errln("Invalid era :" + gc.get(ERA)
+ + ", expected :" + data[index][ERA]);
}
if (gc.get(YEAR) != data[index][YEAR]) {
- errln("Invalid year :" + gc.get(YEAR) +
- ", expected :" + data[index][YEAR]);
+ errln("Invalid year :" + gc.get(YEAR)
+ + ", expected :" + data[index][YEAR]);
}
if (gc.get(MONTH) != data[index][MONTH]) {
- errln("Invalid month :" + gc.get(MONTH) +
- ", expected :" + data[index][MONTH]);
+ errln("Invalid month :" + gc.get(MONTH)
+ + ", expected :" + data[index][MONTH]);
}
}
@@ -97,36 +95,35 @@
TimeZone.setDefault(TimeZone.getTimeZone("PST"));
/* Set March 3, A.D. 2 */
- gc = new GregorianCalendar(2, MARCH, 3);
+ gc = new GregorianCalendar(2, MARCH, 3);
for (int i = 0; i < tablesize; i++) {
check(gc, i);
- gc.add(gc.MONTH, -1);
+ gc.add(MONTH, -1);
}
/* Again, Set March 3, A.D. 2 */
- gc = new GregorianCalendar(2, MARCH, 3);
- for (int i = 0; i < tablesize; i+=7) {
+ gc = new GregorianCalendar(2, MARCH, 3);
+ for (int i = 0; i < tablesize; i += 7) {
check(gc, i);
- gc.add(gc.MONTH, -7);
+ gc.add(MONTH, -7);
}
/* Set March 10, 2 B.C. */
- gc = new GregorianCalendar(2, OCTOBER, 10);
- gc.add(gc.YEAR, -3);
- for (int i = tablesize -1; i >= 0; i--) {
+ gc = new GregorianCalendar(2, OCTOBER, 10);
+ gc.add(YEAR, -3);
+ for (int i = tablesize - 1; i >= 0; i--) {
check(gc, i);
- gc.add(gc.MONTH, 1);
+ gc.add(MONTH, 1);
}
/* Again, Set March 10, 2 B.C. */
- gc = new GregorianCalendar(2, OCTOBER, 10);
- gc.add(gc.YEAR, -3);
- for (int i = tablesize -1; i >= 0; i-=8) {
+ gc = new GregorianCalendar(2, OCTOBER, 10);
+ gc.add(YEAR, -3);
+ for (int i = tablesize - 1; i >= 0; i -= 8) {
check(gc, i);
- gc.add(gc.MONTH, 8);
+ gc.add(MONTH, 8);
}
- }
- finally {
+ } finally {
TimeZone.setDefault(saveZone);
}
}
--- a/jdk/test/java/util/Calendar/bug4401223.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/bug4401223.java Thu Nov 17 11:40:50 2016 +0530
@@ -28,7 +28,10 @@
* @library /java/text/testlib
*/
-import java.util.*;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+import static java.util.GregorianCalendar.*;
public class bug4401223 extends IntlTest {
@@ -37,11 +40,12 @@
String s = null;
try {
- Date date = new Date(2000-1900, Calendar.FEBRUARY, 29);
+ @SuppressWarnings("deprecation")
+ Date date = new Date(2000 - 1900, FEBRUARY, 29);
GregorianCalendar gc = new GregorianCalendar();
gc.setTime(date);
gc.setLenient(false);
- gc.set(Calendar.YEAR, 2001);
+ gc.set(YEAR, 2001);
s = "02/29/00 & set(YEAR,2001) = " + gc.getTime().toString();
} catch (Exception ex) {
status++;
@@ -59,16 +63,17 @@
String s = null;
try {
- Date date = new Date(2000-1900, Calendar.DECEMBER, 31);
+ @SuppressWarnings("deprecation")
+ Date date = new Date(2000 - 1900, DECEMBER, 31);
GregorianCalendar gc = new GregorianCalendar();
gc.setTime(date);
gc.setLenient(false);
- gc.set(Calendar.YEAR, 2001);
+ gc.set(YEAR, 2001);
- if (gc.get(Calendar.YEAR) != 2001 ||
- gc.get(Calendar.MONTH) != Calendar.DECEMBER ||
- gc.get(Calendar.DATE) != 31 ||
- gc.get(Calendar.DAY_OF_YEAR) != 365) {
+ if (gc.get(YEAR) != 2001
+ || gc.get(MONTH) != DECEMBER
+ || gc.get(DATE) != 31
+ || gc.get(DAY_OF_YEAR) != 365) {
status++;
s = "Wrong Date : 12/31/00 & set(YEAR,2001) ---> " + gc.getTime().toString();
} else {
--- a/jdk/test/java/util/Calendar/bug4514831.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Calendar/bug4514831.java Thu Nov 17 11:40:50 2016 +0530
@@ -27,7 +27,12 @@
* @summary Confirm that GregorianCalendar.roll() works properly during transition from Daylight Saving Time to Standard Time.
*/
-import java.util.*;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.TimeZone;
+
+import static java.util.GregorianCalendar.*;
+
public class bug4514831 {
@@ -36,52 +41,52 @@
TimeZone savedTimeZone = TimeZone.getDefault();
boolean err = false;
- String golden_data1 ="27-28 28-29 29-30 30-31 31-1 1-2 2-3 ";
- String golden_data2 ="27-28 28-29 29-30 30-31 31-25 25-26 26-27 ";
- String golden_data3 ="1-8 8-15 15-22 22-29 29-1 1-8 8-15 ";
+ String golden_data1 = "27-28 28-29 29-30 30-31 31-1 1-2 2-3 ";
+ String golden_data2 = "27-28 28-29 29-30 30-31 31-25 25-26 26-27 ";
+ String golden_data3 = "1-8 8-15 15-22 22-29 29-1 1-8 8-15 ";
try {
Locale.setDefault(Locale.US);
TimeZone.setDefault(TimeZone.getTimeZone("US/Pacific"));
String test_roll = "";
- GregorianCalendar c_roll = new GregorianCalendar(2001, Calendar.OCTOBER, 27);
- for (int i=0; i < 7; i++) {
- test_roll += c_roll.get(c_roll.DAY_OF_MONTH) + "-";
- c_roll.roll(c_roll.DAY_OF_YEAR, true);
- test_roll += c_roll.get(c_roll.DAY_OF_MONTH) + " ";
+ GregorianCalendar c_roll = new GregorianCalendar(2001, OCTOBER, 27);
+ for (int i = 0; i < 7; i++) {
+ test_roll += c_roll.get(DAY_OF_MONTH) + "-";
+ c_roll.roll(DAY_OF_YEAR, true);
+ test_roll += c_roll.get(DAY_OF_MONTH) + " ";
}
if (!test_roll.equals(golden_data1)) {
err = true;
- System.err.println("Wrong roll(DAY_OF_YEAR) transition: got "+
- test_roll + "expected " + golden_data1);
+ System.err.println("Wrong roll(DAY_OF_YEAR) transition: got "
+ + test_roll + "expected " + golden_data1);
}
test_roll = "";
- c_roll = new GregorianCalendar(2001, Calendar.OCTOBER, 27);
- c_roll.setFirstDayOfWeek(Calendar.THURSDAY);
- for (int i=0; i < 7; i++) {
- test_roll += c_roll.get(c_roll.DAY_OF_MONTH) + "-";
- c_roll.roll(c_roll.DAY_OF_WEEK, true);
- test_roll += c_roll.get(c_roll.DAY_OF_MONTH) + " ";
+ c_roll = new GregorianCalendar(2001, OCTOBER, 27);
+ c_roll.setFirstDayOfWeek(THURSDAY);
+ for (int i = 0; i < 7; i++) {
+ test_roll += c_roll.get(DAY_OF_MONTH) + "-";
+ c_roll.roll(DAY_OF_WEEK, true);
+ test_roll += c_roll.get(DAY_OF_MONTH) + " ";
}
if (!test_roll.equals(golden_data2)) {
err = true;
- System.err.println("Wrong roll(DAY_OF_WEEK) transition: got "+
- test_roll + "expected " + golden_data2);
+ System.err.println("Wrong roll(DAY_OF_WEEK) transition: got "
+ + test_roll + "expected " + golden_data2);
}
test_roll = "";
- c_roll = new GregorianCalendar(2001, Calendar.OCTOBER, 1);
- for (int i=0; i < 7; i++) {
- test_roll += c_roll.get(c_roll.DAY_OF_MONTH) + "-";
- c_roll.roll(c_roll.DAY_OF_WEEK_IN_MONTH, true);
- test_roll += c_roll.get(c_roll.DAY_OF_MONTH) + " ";
+ c_roll = new GregorianCalendar(2001, OCTOBER, 1);
+ for (int i = 0; i < 7; i++) {
+ test_roll += c_roll.get(DAY_OF_MONTH) + "-";
+ c_roll.roll(DAY_OF_WEEK_IN_MONTH, true);
+ test_roll += c_roll.get(DAY_OF_MONTH) + " ";
}
if (!test_roll.equals(golden_data3)) {
err = true;
- System.err.println("Wrong roll(DAY_OF_WEEK_IN_MONTH) transition: got "+
- test_roll + "expected " + golden_data3);
+ System.err.println("Wrong roll(DAY_OF_WEEK_IN_MONTH) transition: got "
+ + test_roll + "expected " + golden_data3);
}
} finally {
Locale.setDefault(savedLocale);
--- a/jdk/test/java/util/Date/Bug4955000.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Date/Bug4955000.java Thu Nov 17 11:40:50 2016 +0530
@@ -28,11 +28,15 @@
* same date/time. Both are new implementations in 1.5.
*/
-import java.util.*;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.TimeZone;
+
import static java.util.GregorianCalendar.*;
@SuppressWarnings("deprecation")
public class Bug4955000 {
+
// Tests for Date.UTC(), derived from JCK
// Date.miscTests.Date1025 and Date2015
public static void main(String[] args) {
@@ -51,17 +55,17 @@
};
for (int i = 0; i < years1.length; i++) {
gc.clear();
- gc.set(years1[i], gc.JANUARY, 1);
+ gc.set(years1[i], JANUARY, 1);
long t = gc.getTimeInMillis();
- long utc = Date.UTC(years1[i] - 1900, 1-1, 1,
- 0, 0, 0); // Jan 1 00:00:00
+ long utc = Date.UTC(years1[i] - 1900, 1 - 1, 1,
+ 0, 0, 0); // Jan 1 00:00:00
if (t != utc) {
- throw new RuntimeException("t (" + t + ") != utc (" + utc +")");
+ throw new RuntimeException("t (" + t + ") != utc (" + utc + ")");
}
}
// Date2015
- int years[] = {
+ int[] years = {
gc.getGreatestMinimum(YEAR),
gc.getGreatestMinimum(YEAR) + 1,
-1,
@@ -71,47 +75,47 @@
gc.getLeastMaximum(YEAR)
};
- int months[] = {
+ int[] months = {
gc.getMinimum(MONTH),
gc.getMinimum(MONTH) + 1,
gc.getMaximum(MONTH) - 1,
gc.getMaximum(MONTH)
};
- int dates[] = {
+ int[] dates = {
gc.getMinimum(DAY_OF_MONTH),
gc.getMinimum(DAY_OF_MONTH) + 1,
gc.getMaximum(DAY_OF_MONTH) - 1,
gc.getMaximum(DAY_OF_MONTH)
};
- int hs[] = {
+ int[] hs = {
gc.getMinimum(HOUR),
gc.getMinimum(HOUR) + 1,
gc.getMaximum(HOUR) - 1,
gc.getMaximum(HOUR)
};
- int ms[] = {
+ int[] ms = {
gc.getMinimum(MINUTE),
gc.getMinimum(MINUTE) + 1,
gc.getMaximum(MINUTE) - 1,
gc.getMaximum(MINUTE)
};
- int ss[] = {
+ int[] ss = {
gc.getMinimum(SECOND),
gc.getMinimum(SECOND) + 1,
gc.getMaximum(SECOND) - 1,
gc.getMaximum(SECOND)
};
- for(int i = 0; i < years.length; i++) {
- for(int j = 0; j < months.length; j++) {
- for(int k = 0; k < dates.length; k++) {
- for(int m = 0; m < hs.length; m++) {
- for(int n = 0; n < ms.length; n++) {
- for(int p = 0; p < ss.length; p++) {
+ for (int i = 0; i < years.length; i++) {
+ for (int j = 0; j < months.length; j++) {
+ for (int k = 0; k < dates.length; k++) {
+ for (int m = 0; m < hs.length; m++) {
+ for (int n = 0; n < ms.length; n++) {
+ for (int p = 0; p < ss.length; p++) {
int year = years[i] - 1900;
int month = months[j];
int date = dates[k];
@@ -120,7 +124,7 @@
int seconds = ss[p];
long result = Date.UTC(year, month, date,
- hours, minutes, seconds);
+ hours, minutes, seconds);
gc.clear();
gc.set(year + 1900, month, date, hours, minutes, seconds);
@@ -129,7 +133,7 @@
if (expected != result) {
throw new RuntimeException("expected (" + expected
- + ") != result (" + result +")");
+ + ") != result (" + result + ")");
}
}
}
--- a/jdk/test/java/util/Locale/Bug4175998Test.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Locale/Bug4175998Test.java Thu Nov 17 11:40:50 2016 +0530
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2007, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2016, 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
@@ -24,6 +24,7 @@
/*
* @test
* @summary test ISO639-2 language codes
+ * @library /java/text/testlib
* @compile -encoding ascii Bug4175998Test.java
* @run main Bug4175998Test
* @bug 4175998
@@ -43,14 +44,13 @@
*/
import java.util.*;
-import java.io.*;
/**
* Bug4175998Test verifies that the following bug has been fixed:
* Bug 4175998 - The java.util.Locale.getISO3Language() returns wrong result for a locale with
* language code 'ta'(Tamil).
*/
-public class Bug4175998Test extends LocaleTestFmwk {
+public class Bug4175998Test extends IntlTest {
public static void main(String[] args) throws Exception {
new Bug4175998Test().run(args);
//generateTables(); //uncomment this to regenerate data tables
--- a/jdk/test/java/util/Locale/Bug4184873Test.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Locale/Bug4184873Test.java Thu Nov 17 11:40:50 2016 +0530
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2016, 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
@@ -23,6 +23,7 @@
/*
@test
@summary test that locale invariants are preserved across serialization
+ @library /java/text/testlib
@run main Bug4184873Test
@bug 4184873
*/
@@ -63,7 +64,7 @@
/**
* A Locale can never contain the following language codes: he, yi or id.
*/
-public class Bug4184873Test extends LocaleTestFmwk {
+public class Bug4184873Test extends IntlTest {
public static void main(String[] args) throws Exception {
if (args.length == 1 && args[0].equals("prepTest")) {
prepTest();
--- a/jdk/test/java/util/Locale/Bug8001562.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Locale/Bug8001562.java Thu Nov 17 11:40:50 2016 +0530
@@ -30,37 +30,46 @@
* @run main Bug8001562
*/
-import java.text.*;
-import java.util.*;
+import java.text.BreakIterator;
+import java.text.Collator;
+import java.text.DateFormat;
+import java.text.DateFormatSymbols;
+import java.text.DecimalFormatSymbols;
+import java.text.NumberFormat;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+import java.util.stream.Collectors;
public class Bug8001562 {
- static final String[] jdk7availTags = {
- "ar", "ar-AE", "ar-BH", "ar-DZ", "ar-EG", "ar-IQ", "ar-JO", "ar-KW",
- "ar-LB", "ar-LY", "ar-MA", "ar-OM", "ar-QA", "ar-SA", "ar-SD", "ar-SY",
- "ar-TN", "ar-YE", "be", "be-BY", "bg", "bg-BG", "ca", "ca-ES", "cs",
- "cs-CZ", "da", "da-DK", "de", "de-AT", "de-CH", "de-DE", "de-LU", "el",
- "el-CY", "el-GR", "en", "en-AU", "en-CA", "en-GB", "en-IE", "en-IN",
- "en-MT", "en-NZ", "en-PH", "en-SG", "en-US", "en-ZA", "es", "es-AR",
- "es-BO", "es-CL", "es-CO", "es-CR", "es-DO", "es-EC", "es-ES", "es-GT",
- "es-HN", "es-MX", "es-NI", "es-PA", "es-PE", "es-PR", "es-PY", "es-SV",
- "es-US", "es-UY", "es-VE", "et", "et-EE", "fi", "fi-FI", "fr", "fr-BE",
- "fr-CA", "fr-CH", "fr-FR", "fr-LU", "ga", "ga-IE", "he", "he-IL",
- "hi-IN", "hr", "hr-HR", "hu", "hu-HU", "id", "id-ID", "is", "is-IS",
- "it", "it-CH", "it-IT", "ja", "ja-JP",
- "ja-JP-u-ca-japanese-x-lvariant-JP", "ko", "ko-KR", "lt", "lt-LT", "lv",
- "lv-LV", "mk", "mk-MK", "ms", "ms-MY", "mt", "mt-MT", "nl", "nl-BE",
- "nl-NL", "no", "no-NO", "no-NO-x-lvariant-NY", "pl", "pl-PL", "pt",
- "pt-BR", "pt-PT", "ro", "ro-RO", "ru", "ru-RU", "sk", "sk-SK", "sl",
- "sl-SI", "sq", "sq-AL", "sr", "sr-BA", "sr-CS", "sr-Latn", "sr-Latn-BA",
- "sr-Latn-ME", "sr-Latn-RS", "sr-ME", "sr-RS", "sv", "sv-SE", "th",
- "th-TH", "th-TH-u-nu-thai-x-lvariant-TH", "tr", "tr-TR", "uk", "uk-UA",
- "vi", "vi-VN", "zh", "zh-CN", "zh-HK", "zh-SG", "zh-TW", };
- static List<Locale> jdk7availLocs = new ArrayList<>();
+ static final List<String> jdk7availTags = List.of(
+ "ar", "ar-AE", "ar-BH", "ar-DZ", "ar-EG", "ar-IQ", "ar-JO", "ar-KW",
+ "ar-LB", "ar-LY", "ar-MA", "ar-OM", "ar-QA", "ar-SA", "ar-SD", "ar-SY",
+ "ar-TN", "ar-YE", "be", "be-BY", "bg", "bg-BG", "ca", "ca-ES", "cs",
+ "cs-CZ", "da", "da-DK", "de", "de-AT", "de-CH", "de-DE", "de-LU", "el",
+ "el-CY", "el-GR", "en", "en-AU", "en-CA", "en-GB", "en-IE", "en-IN",
+ "en-MT", "en-NZ", "en-PH", "en-SG", "en-US", "en-ZA", "es", "es-AR",
+ "es-BO", "es-CL", "es-CO", "es-CR", "es-DO", "es-EC", "es-ES", "es-GT",
+ "es-HN", "es-MX", "es-NI", "es-PA", "es-PE", "es-PR", "es-PY", "es-SV",
+ "es-US", "es-UY", "es-VE", "et", "et-EE", "fi", "fi-FI", "fr", "fr-BE",
+ "fr-CA", "fr-CH", "fr-FR", "fr-LU", "ga", "ga-IE", "he", "he-IL",
+ "hi-IN", "hr", "hr-HR", "hu", "hu-HU", "id", "id-ID", "is", "is-IS",
+ "it", "it-CH", "it-IT", "ja", "ja-JP",
+ "ja-JP-u-ca-japanese-x-lvariant-JP", "ko", "ko-KR", "lt", "lt-LT", "lv",
+ "lv-LV", "mk", "mk-MK", "ms", "ms-MY", "mt", "mt-MT", "nl", "nl-BE",
+ "nl-NL", "no", "no-NO", "no-NO-x-lvariant-NY", "pl", "pl-PL", "pt",
+ "pt-BR", "pt-PT", "ro", "ro-RO", "ru", "ru-RU", "sk", "sk-SK", "sl",
+ "sl-SI", "sq", "sq-AL", "sr", "sr-BA", "sr-CS", "sr-Latn", "sr-Latn-BA",
+ "sr-Latn-ME", "sr-Latn-RS", "sr-ME", "sr-RS", "sv", "sv-SE", "th",
+ "th-TH", "th-TH-u-nu-thai-x-lvariant-TH", "tr", "tr-TR", "uk", "uk-UA",
+ "vi", "vi-VN", "zh", "zh-CN", "zh-HK", "zh-SG", "zh-TW");
+ static List<Locale> jdk7availLocs;
+
static {
- for (String locStr : jdk7availTags) {
- jdk7availLocs.add(Locale.forLanguageTag(locStr));
- }
+ jdk7availLocs = jdk7availTags.stream()
+ .map(Locale::forLanguageTag)
+ .collect(Collectors.toList());
}
public static void main(String[] args) {
@@ -86,13 +95,13 @@
diffLocale(Locale.class, avail);
}
- static void diffLocale(Class c, List<Locale> locs) {
+ static void diffLocale(Class<?> c, List<Locale> locs) {
String diff = "";
System.out.printf("Only in target locales (%s.getAvailableLocales()): ", c.getSimpleName());
for (Locale l : locs) {
if (!jdk7availLocs.contains(l)) {
- diff += "\""+l.toLanguageTag()+"\", ";
+ diff += "\"" + l.toLanguageTag() + "\", ";
}
}
System.out.println(diff);
@@ -101,7 +110,7 @@
System.out.printf("Only in JDK7 (%s.getAvailableLocales()): ", c.getSimpleName());
for (Locale l : jdk7availLocs) {
if (!locs.contains(l)) {
- diff += "\""+l.toLanguageTag()+"\", ";
+ diff += "\"" + l.toLanguageTag() + "\", ";
}
}
System.out.println(diff);
--- a/jdk/test/java/util/Locale/HashCodeTest.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Locale/HashCodeTest.java Thu Nov 17 11:40:50 2016 +0530
@@ -27,14 +27,17 @@
* @modules jdk.localedata
*/
-import java.util.*;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
public class HashCodeTest {
+
public static void main(String[] args) {
Locale[] locales = Locale.getAvailableLocales();
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
- Map map = new HashMap(locales.length);
+ Map<Integer, Locale> map = new HashMap<>(locales.length);
int conflicts = 0;
for (int i = 0; i < locales.length; i++) {
@@ -42,19 +45,19 @@
int hc = loc.hashCode();
min = Math.min(hc, min);
max = Math.max(hc, max);
- Integer key = new Integer(hc);
+ Integer key = hc;
if (map.containsKey(key)) {
conflicts++;
- System.out.println("conflict: " + (Locale) map.get(key) + ", " + loc);
+ System.out.println("conflict: " + map.get(key) + ", " + loc);
} else {
map.put(key, loc);
}
}
- System.out.println(locales.length+" locales: conflicts="+conflicts
- +", min="+min+", max="+max +", diff="+(max-min));
+ System.out.println(locales.length + " locales: conflicts=" + conflicts
+ + ", min=" + min + ", max=" + max + ", diff=" + (max - min));
if (conflicts >= (locales.length / 10)) {
throw new RuntimeException("too many conflicts: " + conflicts
- + " per " + locales.length + " locales");
+ + " per " + locales.length + " locales");
}
}
}
--- a/jdk/test/java/util/Locale/LocaleEnhanceTest.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Locale/LocaleEnhanceTest.java Thu Nov 17 11:40:50 2016 +0530
@@ -46,11 +46,12 @@
* @bug 6875847 6992272 7002320 7015500 7023613 7032820 7033504 7004603
* 7044019 8008577
* @summary test API changes to Locale
+ * @library /java/text/testlib
* @modules jdk.localedata
* @compile LocaleEnhanceTest.java
* @run main/othervm -Djava.locale.providers=JRE,SPI -esa LocaleEnhanceTest
*/
-public class LocaleEnhanceTest extends LocaleTestFmwk {
+public class LocaleEnhanceTest extends IntlTest {
public static void main(String[] args) throws Exception {
List<String> argList = new ArrayList<String>();
--- a/jdk/test/java/util/Locale/LocaleTest.java Wed Nov 16 17:29:14 2016 -0800
+++ b/jdk/test/java/util/Locale/LocaleTest.java Thu Nov 17 11:40:50 2016 +0530
@@ -27,6 +27,7 @@
* 4147315 4147317 4147552 4335196 4778440 4940539 5010672 6475525 6544471 6627549
* 6786276 7066203 7085757 8008577 8030696
* @summary test Locales
+ * @library /java/text/testlib
* @modules jdk.localedata
* @run main/othervm -Djava.locale.providers=JRE,SPI LocaleTest
*/
@@ -63,16 +64,25 @@
*
*/
-import java.text.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OptionalDataException;
+import java.io.StreamCorruptedException;
+import java.text.DateFormat;
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.text.SimpleDateFormat;
import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.MissingResourceException;
-import java.util.Date;
-import java.util.Calendar;
-import java.io.*;
-public class LocaleTest extends LocaleTestFmwk {
+public class LocaleTest extends IntlTest {
public LocaleTest() {
}
@@ -186,18 +196,22 @@
Locale testLocale = new Locale(dataTable[LANG][i], dataTable[CTRY][i], dataTable[VAR][i]);
logln("Testing " + testLocale + "...");
- if (!testLocale.getLanguage().equals(dataTable[LANG][i]))
+ if (!testLocale.getLanguage().equals(dataTable[LANG][i])) {
errln(" Language code mismatch: " + testLocale.getLanguage() + " versus "
- + dataTable[LANG][i]);
- if (!testLocale.getCountry().equals(dataTable[CTRY][i]))
+ + dataTable[LANG][i]);
+ }
+ if (!testLocale.getCountry().equals(dataTable[CTRY][i])) {
errln(" Country code mismatch: " + testLocale.getCountry() + " versus "
- + dataTable[CTRY][i]);
- if (!testLocale.getVariant().equals(dataTable[VAR][i]))
+ + dataTable[CTRY][i]);
+ }
+ if (!testLocale.getVariant().equals(dataTable[VAR][i])) {
errln(" Variant code mismatch: " + testLocale.getVariant() + " versus "
- + dataTable[VAR][i]);
- if (!testLocale.toString().equals(dataTable[NAME][i]))
+ + dataTable[VAR][i]);
+ }
+ if (!testLocale.toString().equals(dataTable[NAME][i])) {
errln(" Locale name mismatch: " + testLocale.toString() + " versus "
- + dataTable[NAME][i]);
+ + dataTable[NAME][i]);
+ }
}
logln("Same thing without variant codes...");
@@ -205,31 +219,37 @@
Locale testLocale = new Locale(dataTable[LANG][i], dataTable[CTRY][i]);
logln("Testing " + testLocale + "...");
- if (!testLocale.getLanguage().equals(dataTable[LANG][i]))
+ if (!testLocale.getLanguage().equals(dataTable[LANG][i])) {
errln(" Language code mismatch: " + testLocale.getLanguage() + " versus "
- + dataTable[LANG][i]);
- if (!testLocale.getCountry().equals(dataTable[CTRY][i]))
+ + dataTable[LANG][i]);
+ }
+ if (!testLocale.getCountry().equals(dataTable[CTRY][i])) {
errln(" Country code mismatch: " + testLocale.getCountry() + " versus "
- + dataTable[CTRY][i]);
- if (!testLocale.getVariant().equals(""))
+ + dataTable[CTRY][i]);
+ }
+ if (!testLocale.getVariant().equals("")) {
errln(" Variant code mismatch: " + testLocale.getVariant() + " versus \"\"");
+ }
}
}
public void TestSimpleResourceInfo() {
for (int i = 0; i <= MAX_LOCALES; i++) {
- if (dataTable[LANG][i].equals("xx"))
+ if (dataTable[LANG][i].equals("xx")) {
continue;
+ }
Locale testLocale = new Locale(dataTable[LANG][i], dataTable[CTRY][i], dataTable[VAR][i]);
logln("Testing " + testLocale + "...");
- if (!testLocale.getISO3Language().equals(dataTable[LANG3][i]))
+ if (!testLocale.getISO3Language().equals(dataTable[LANG3][i])) {
errln(" ISO-3 language code mismatch: " + testLocale.getISO3Language()
- + " versus " + dataTable[LANG3][i]);
- if (!testLocale.getISO3Country().equals(dataTable[CTRY3][i]))
+ + " versus " + dataTable[LANG3][i]);
+ }
+ if (!testLocale.getISO3Country().equals(dataTable[CTRY3][i])) {
errln(" ISO-3 country code mismatch: " + testLocale.getISO3Country()
- + " versus " + dataTable[CTRY3][i]);
+ + " versus " + dataTable[CTRY3][i]);
+ }
/*
// getLCID() is currently private
if (!String.valueOf(testLocale.getLCID()).equals(dataTable[LCID][i]))
@@ -246,11 +266,11 @@
* @bug 4052440 Stop falling back to the default locale.
*/
public void TestDisplayNames() {
- Locale saveDefault = Locale.getDefault();
- Locale english = new Locale("en", "US");
- Locale french = new Locale("fr", "FR");
- Locale croatian = new Locale("hr", "HR");
- Locale greek = new Locale("el", "GR");
+ Locale saveDefault = Locale.getDefault();
+ Locale english = new Locale("en", "US");
+ Locale french = new Locale("fr", "FR");
+ Locale croatian = new Locale("hr", "HR");
+ Locale greek = new Locale("el", "GR");
Locale.setDefault(english);
logln("With default = en_US...");
@@ -282,97 +302,116 @@
}
private void doTestDisplayNames(Locale inLocale, int compareIndex, boolean defaultIsFrench) {
- if (defaultIsFrench && !Locale.getDefault().getLanguage().equals("fr"))
- errln("Default locale should be French, but it's really " + Locale.getDefault().getLanguage());
- else if (!defaultIsFrench && !Locale.getDefault().getLanguage().equals("en"))
- errln("Default locale should be English, but it's really " + Locale.getDefault().getLanguage());
+ String language = Locale.getDefault().getLanguage();
+
+ if (defaultIsFrench && !language.equals("fr")) {
+ errln("Default locale should be French, but it's really " + language);
+ } else if (!defaultIsFrench && !language.equals("en")) {
+ errln("Default locale should be English, but it's really " + language);
+ }
for (int i = 0; i <= MAX_LOCALES; i++) {
Locale testLocale = new Locale(dataTable[LANG][i], dataTable[CTRY][i], dataTable[VAR][i]);
logln(" Testing " + testLocale + "...");
- String testLang;
- String testCtry;
- String testVar;
- String testName;
+ String testLang;
+ String testCtry;
+ String testVar;
+ String testName;
if (inLocale == null) {
testLang = testLocale.getDisplayLanguage();
testCtry = testLocale.getDisplayCountry();
testVar = testLocale.getDisplayVariant();
testName = testLocale.getDisplayName();
- }
- else {
+ } else {
testLang = testLocale.getDisplayLanguage(inLocale);
testCtry = testLocale.getDisplayCountry(inLocale);
testVar = testLocale.getDisplayVariant(inLocale);
testName = testLocale.getDisplayName(inLocale);
}
- String expectedLang;
- String expectedCtry;
- String expectedVar;
- String expectedName;
+ String expectedLang;
+ String expectedCtry;
+ String expectedVar;
+ String expectedName;
expectedLang = dataTable[compareIndex][i];
- if (expectedLang.equals("") && defaultIsFrench)
+ if (expectedLang.equals("") && defaultIsFrench) {
expectedLang = dataTable[DLANG_EN][i];
- if (expectedLang.equals(""))
+ }
+ if (expectedLang.equals("")) {
expectedLang = dataTable[DLANG_ROOT][i];
+ }
expectedCtry = dataTable[compareIndex + 1][i];
- if (expectedCtry.equals("") && defaultIsFrench)
+ if (expectedCtry.equals("") && defaultIsFrench) {
expectedCtry = dataTable[DCTRY_EN][i];
- if (expectedCtry.equals(""))
+ }
+ if (expectedCtry.equals("")) {
expectedCtry = dataTable[DCTRY_ROOT][i];
+ }
expectedVar = dataTable[compareIndex + 2][i];
- if (expectedVar.equals("") && defaultIsFrench)
+ if (expectedVar.equals("") && defaultIsFrench) {
expectedVar = dataTable[DVAR_EN][i];
- if (expectedVar.equals(""))
+ }
+ if (expectedVar.equals("")) {
expectedVar = dataTable[DVAR_ROOT][i];
+ }
expectedName = dataTable[compareIndex + 3][i];
- if (expectedName.equals("") && defaultIsFrench)
+ if (expectedName.equals("") && defaultIsFrench) {
expectedName = dataTable[DNAME_EN][i];
- if (expectedName.equals(""))
+ }
+ if (expectedName.equals("")) {
expectedName = dataTable[DNAME_ROOT][i];
+ }
- if (!testLang.equals(expectedLang))
+ if (!testLang.equals(expectedLang)) {
errln("Display language mismatch: " + testLang + " versus " + expectedLang);
- if (!testCtry.equals(expectedCtry))
+ }
+ if (!testCtry.equals(expectedCtry)) {
errln("Display country mismatch: " + testCtry + " versus " + expectedCtry);
- if (!testVar.equals(expectedVar))
+ }
+ if (!testVar.equals(expectedVar)) {
errln("Display variant mismatch: " + testVar + " versus " + expectedVar);
- if (!testName.equals(expectedName))
+ }
+ if (!testName.equals(expectedName)) {
errln("Display name mismatch: " + testName + " versus " + expectedName);
+ }
}
}
public void TestSimpleObjectStuff() {
- Locale test1 = new Locale("aa", "AA");
- Locale test2 = new Locale("aa", "AA");
- Locale test3 = (Locale)test1.clone();
- Locale test4 = new Locale("zz", "ZZ");
+ Locale test1 = new Locale("aa", "AA");
+ Locale test2 = new Locale("aa", "AA");
+ Locale test3 = (Locale) test1.clone();
+ Locale test4 = new Locale("zz", "ZZ");
- if (test1 == test2 || test1 == test3 || test1 == test4 || test2 == test3)
+ if (test1 == test2 || test1 == test3 || test1 == test4 || test2 == test3) {
errln("Some of the test variables point to the same locale!");
+ }
- if (test3 == null)
+ if (test3 == null) {
errln("clone() failed to produce a valid object!");
+ }
- if (!test1.equals(test2) || !test1.equals(test3) || !test2.equals(test3))
+ if (!test1.equals(test2) || !test1.equals(test3) || !test2.equals(test3)) {
errln("clone() or equals() failed: objects that should compare equal don't");
+ }
- if (test1.equals(test4) || test2.equals(test4) || test3.equals(test4))
+ if (test1.equals(test4) || test2.equals(test4) || test3.equals(test4)) {
errln("equals() failed: objects that shouldn't compare equal do");
+ }
int hash1 = test1.hashCode();
int hash2 = test2.hashCode();
int hash3 = test3.hashCode();
- if (hash1 != hash2 || hash1 != hash3 || hash2 != hash3)
+ if (hash1 != hash2 || hash1 != hash3 || hash2 != hash3) {
errln("hashCode() failed: objects that should have the same hash code don't");
+ }
}
/**
@@ -385,22 +424,22 @@
try {
result = test.getISO3Language();
- }
- catch (MissingResourceException e) {
+ } catch (MissingResourceException e) {
gotException = true;
}
- if (!gotException)
+ if (!gotException) {
errln("getISO3Language() on xx_YY returned " + result + " instead of throwing an exception");
+ }
gotException = false;
try {
result = test.getISO3Country();
- }
- catch (MissingResourceException e) {
+ } catch (MissingResourceException e) {
gotException = true;
}
- if (!gotException)
+ if (!gotException) {
errln("getISO3Country() on xx_YY returned " + result + " instead of throwing an exception");
+ }
}
/**
@@ -416,53 +455,65 @@
// all lower case for the language codes, all upper case for the country codes)
// 4) Is each list in sorted order?
String[] test = Locale.getISOLanguages();
- String[] spotCheck1 = { "en", "es", "fr", "de", "it", "ja", "ko", "zh", "th",
- "he", "id", "iu", "ug", "yi", "za" };
+ String[] spotCheck1 = {"en", "es", "fr", "de", "it", "ja", "ko", "zh", "th",
+ "he", "id", "iu", "ug", "yi", "za"};
- if (test.length != 188)
+ if (test.length != 188) {
errln("Expected getISOLanguages() to return 188 languages; it returned " + test.length);
- else {
+ } else {
for (int i = 0; i < spotCheck1.length; i++) {
int j;
- for (j = 0; j < test.length; j++)
- if (test[j].equals(spotCheck1[i]))
+ for (j = 0; j < test.length; j++) {
+ if (test[j].equals(spotCheck1[i])) {
break;
- if (j == test.length || !test[j].equals(spotCheck1[i]))
+ }
+ }
+ if (j == test.length || !test[j].equals(spotCheck1[i])) {
errln("Couldn't find " + spotCheck1[i] + " in language list.");
+ }
}
}
for (int i = 0; i < test.length; i++) {
- if (!test[i].equals(test[i].toLowerCase()))
+ if (!test[i].equals(test[i].toLowerCase())) {
errln(test[i] + " is not all lower case.");
- if (test[i].length() != 2)
+ }
+ if (test[i].length() != 2) {
errln(test[i] + " is not two characters long.");
- if (i > 0 && test[i].compareTo(test[i - 1]) <= 0)
+ }
+ if (i > 0 && test[i].compareTo(test[i - 1]) <= 0) {
errln(test[i] + " appears in an out-of-order position in the list.");
+ }
}
test = Locale.getISOCountries();
- String[] spotCheck2 = { "US", "CA", "GB", "FR", "DE", "IT", "JP", "KR", "CN", "TW", "TH" };
+ String[] spotCheck2 = {"US", "CA", "GB", "FR", "DE", "IT", "JP", "KR", "CN", "TW", "TH"};
- if (test.length != 250)
+ if (test.length != 250) {
errln("Expected getISOCountries to return 250 countries; it returned " + test.length);
- else {
+ } else {
for (int i = 0; i < spotCheck2.length; i++) {
int j;
- for (j = 0; j < test.length; j++)
- if (test[j].equals(spotCheck2[i]))
+ for (j = 0; j < test.length; j++) {
+ if (test[j].equals(spotCheck2[i])) {
break;
- if (j == test.length || !test[j].equals(spotCheck2[i]))
+ }
+ }
+ if (j == test.length || !test[j].equals(spotCheck2[i])) {
errln("Couldn't find " + spotCheck2[i] + " in country list.");
+ }
}
}
for (int i = 0; i < test.length; i++) {
- if (!test[i].equals(test[i].toUpperCase()))
+ if (!test[i].equals(test[i].toUpperCase())) {
errln(test[i] + " is not all upper case.");
- if (test[i].length() != 2)
+ }
+ if (test[i].length() != 2) {
errln(test[i] + " is not two characters long.");
- if (i > 0 && test[i].compareTo(test[i - 1]) <= 0)
+ }
+ if (i > 0 && test[i].compareTo(test[i - 1]) <= 0) {
errln(test[i] + " appears in an out-of-order position in the list.");
+ }
}
}
@@ -475,14 +526,16 @@
test = Locale.getISOCountries();
test[0] = "SUCKER!!!";
test = Locale.getISOCountries();
- if (test[0].equals("SUCKER!!!"))
+ if (test[0].equals("SUCKER!!!")) {
errln("Changed internal country code list!");
+ }
test = Locale.getISOLanguages();
test[0] = "HAHAHAHA!!!";
test = Locale.getISOLanguages();
- if (test[0].equals("HAHAHAHA!!!")) // Fixed typo
+ if (test[0].equals("HAHAHAHA!!!")) { // Fixed typo
errln("Changes internal language code list!");
+ }
}
/**
@@ -490,12 +543,13 @@
*/
public void TestGetAvailableLocales() {
Locale[] locales = Locale.getAvailableLocales();
- if (locales == null || locales.length == 0)
+ if (locales == null || locales.length == 0) {
errln("Locale.getAvailableLocales() returned no installed locales!");
- else {
+ } else {
logln("Locale.getAvailableLocales() returned a list of " + locales.length + " locales.");
- for (int i = 0; i < locales.length; i++)
+ for (int i = 0; i < locales.length; i++) {
logln(locales[i].toString());
+ }
}
}
@@ -505,8 +559,9 @@
public void TestBug4135316() {
Locale[] locales1 = Locale.getAvailableLocales();
Locale[] locales2 = Locale.getAvailableLocales();
- if (locales1 == locales2)
+ if (locales1 == locales2) {
errln("Locale.getAvailableLocales() doesn't clone its internal storage!");
+ }
}
/**
@@ -548,8 +603,7 @@
* @bug 4110613
*/
public void TestSerialization() throws ClassNotFoundException, OptionalDataException,
- IOException, StreamCorruptedException
- {
+ IOException, StreamCorruptedException {
ObjectOutputStream ostream;
ByteArrayOutputStream obstream;
byte[] bytes = null;
@@ -565,10 +619,11 @@
ObjectInputStream istream = new ObjectInputStream(new ByteArrayInputStream(bytes));
- Locale test2 = (Locale)(istream.readObject());
+ Locale test2 = (Locale) (istream.readObject());
- if (!test1.equals(test2) || test1.hashCode() != test2.hashCode())
+ if (!test1.equals(test2) || test1.hashCode() != test2.hashCode()) {
errln("Locale failed to deserialize correctly.");
+ }
}
/**
@@ -579,15 +634,16 @@
// fallback behavior, combination of language and country names to form locale
// names, and other stuff like that. This test just checks specific language
// and country codes to make sure we have the correct names for them.
- String[] languageCodes = { "he", "id", "iu", "ug", "yi", "za" };
- String[] languageNames = { "Hebrew", "Indonesian", "Inuktitut", "Uighur", "Yiddish",
- "Zhuang" };
+ String[] languageCodes = {"he", "id", "iu", "ug", "yi", "za"};
+ String[] languageNames = {"Hebrew", "Indonesian", "Inuktitut", "Uighur", "Yiddish",
+ "Zhuang"};
for (int i = 0; i < languageCodes.length; i++) {
String test = (new Locale(languageCodes[i], "", "")).getDisplayLanguage(Locale.US);
- if (!test.equals(languageNames[i]))
- errln("Got wrong display name for " + languageCodes[i] + ": Expected \"" +
- languageNames[i] + "\", got \"" + test + "\".");
+ if (!test.equals(languageNames[i])) {
+ errln("Got wrong display name for " + languageCodes[i] + ": Expected \""
+ + languageNames[i] + "\", got \"" + test + "\".");
+ }
}
}
@@ -597,24 +653,26 @@
public void TestUninstalledISO3Names() {
// This test checks to make sure getISO3Language and getISO3Country work right
// even for locales that are not installed.
- String[] iso2Languages = { "am", "ba", "fy", "mr", "rn", "ss", "tw", "zu" };
- String[] iso3Languages = { "amh", "bak", "fry", "mar", "run", "ssw", "twi", "zul" };
+ String[] iso2Languages = {"am", "ba", "fy", "mr", "rn", "ss", "tw", "zu"};
+ String[] iso3Languages = {"amh", "bak", "fry", "mar", "run", "ssw", "twi", "zul"};
for (int i = 0; i < iso2Languages.length; i++) {
String test = (new Locale(iso2Languages[i], "", "")).getISO3Language();
- if (!test.equals(iso3Languages[i]))
- errln("Got wrong ISO3 code for " + iso2Languages[i] + ": Expected \"" +
- iso3Languages[i] + "\", got \"" + test + "\".");
+ if (!test.equals(iso3Languages[i])) {
+ errln("Got wrong ISO3 code for " + iso2Languages[i] + ": Expected \""
+ + iso3Languages[i] + "\", got \"" + test + "\".");
+ }
}
- String[] iso2Countries = { "AF", "BW", "KZ", "MO", "MN", "SB", "TC", "ZW" };
- String[] iso3Countries = { "AFG", "BWA", "KAZ", "MAC", "MNG", "SLB", "TCA", "ZWE" };
+ String[] iso2Countries = {"AF", "BW", "KZ", "MO", "MN", "SB", "TC", "ZW"};
+ String[] iso3Countries = {"AFG", "BWA", "KAZ", "MAC", "MNG", "SLB", "TCA", "ZWE"};
for (int i = 0; i < iso2Countries.length; i++) {
String test = (new Locale("", iso2Countries[i], "")).getISO3Country();
- if (!test.equals(iso3Countries[i]))
- errln("Got wrong ISO3 code for " + iso2Countries[i] + ": Expected \"" +
- iso3Countries[i] + "\", got \"" + test + "\".");
+ if (!test.equals(iso3Countries[i])) {
+ errln("Got wrong ISO3 code for " + iso2Countries[i] + ": Expected \""
+ + iso3Countries[i] + "\", got \"" + test + "\".");
+ }
}
}
@@ -629,15 +687,18 @@
Locale indonesianOld = new Locale("in", "", "");
Locale indonesianNew = new Locale("id", "", "");
- if (!hebrewNew.getLanguage().equals("iw"))
- errln("Got back wrong language code for Hebrew: expected \"iw\", got \"" +
- hebrewNew.getLanguage() + "\"");
- if (!yiddishNew.getLanguage().equals("ji"))
- errln("Got back wrong language code for Yiddish: expected \"ji\", got \"" +
- yiddishNew.getLanguage() + "\"");
- if (!indonesianNew.getLanguage().equals("in"))
- errln("Got back wrong language code for Indonesian: expected \"in\", got \"" +
- indonesianNew.getLanguage() + "\"");
+ if (!hebrewNew.getLanguage().equals("iw")) {
+ errln("Got back wrong language code for Hebrew: expected \"iw\", got \""
+ + hebrewNew.getLanguage() + "\"");
+ }
+ if (!yiddishNew.getLanguage().equals("ji")) {
+ errln("Got back wrong language code for Yiddish: expected \"ji\", got \""
+ + yiddishNew.getLanguage() + "\"");
+ }
+ if (!indonesianNew.getLanguage().equals("in")) {
+ errln("Got back wrong language code for Indonesian: expected \"in\", got \""
+ + indonesianNew.getLanguage() + "\"");
+ }
}
/**
@@ -703,25 +764,28 @@
for (int i = 0; i < localesToTest.length; i++) {
String name = localesToTest[i].getDisplayName(Locale.US);
logln(name);
- if (!name.equals(englishDisplayNames[i]))
+ if (!name.equals(englishDisplayNames[i])) {
errln("Lookup in English failed: expected \"" + englishDisplayNames[i]
- + "\", got \"" + name + "\"");
+ + "\", got \"" + name + "\"");
+ }
}
for (int i = 0; i < localesToTest.length; i++) {
String name = localesToTest[i].getDisplayName(new Locale("es", "ES"));
logln(name);
- if (!name.equals(spanishDisplayNames[i]))
+ if (!name.equals(spanishDisplayNames[i])) {
errln("Lookup in Spanish failed: expected \"" + spanishDisplayNames[i]
- + "\", got \"" + name + "\"");
+ + "\", got \"" + name + "\"");
+ }
}
for (int i = 0; i < localesToTest.length; i++) {
String name = localesToTest[i].getDisplayName(Locale.FRANCE);
logln(name);
- if (!name.equals(frenchDisplayNames[i]))
+ if (!name.equals(frenchDisplayNames[i])) {
errln("Lookup in French failed: expected \"" + frenchDisplayNames[i]
- + "\", got \"" + name + "\"");
+ + "\", got \"" + name + "\"");
+ }
}
// restore the default locale for other tests
@@ -737,15 +801,16 @@
boolean gotException = false;
try {
Locale.setDefault(null);
- }
- catch (NullPointerException e) {
+ } catch (NullPointerException e) {
// all other exception types propagate through here back to the test harness
gotException = true;
}
- if (Locale.getDefault() == null)
+ if (Locale.getDefault() == null) {
errln("Locale.getDefault() allowed us to set default to NULL!");
- if (!gotException)
+ }
+ if (!gotException) {
errln("Trying to set default locale to NULL didn't throw exception!");
+ }
}
/**
@@ -754,14 +819,16 @@
* get the LocaleDataTest working again.
*/
public void TestThaiCurrencyFormat() {
- DecimalFormat thaiCurrency = (DecimalFormat)NumberFormat.getCurrencyInstance(
- new Locale("th", "TH"));
- if (!thaiCurrency.getPositivePrefix().equals("\u0e3f"))
- errln("Thai currency prefix wrong: expected \"\u0e3f\", got \"" +
- thaiCurrency.getPositivePrefix() + "\"");
- if (!thaiCurrency.getPositiveSuffix().equals(""))
- errln("Thai currency suffix wrong: expected \"\", got \"" +
- thaiCurrency.getPositiveSuffix() + "\"");
+ DecimalFormat thaiCurrency = (DecimalFormat) NumberFormat.getCurrencyInstance(
+ new Locale("th", "TH"));
+ if (!thaiCurrency.getPositivePrefix().equals("\u0e3f")) {
+ errln("Thai currency prefix wrong: expected \"\u0e3f\", got \""
+ + thaiCurrency.getPositivePrefix() + "\"");
+ }
+ if (!thaiCurrency.getPositiveSuffix().equals("")) {
+ errln("Thai currency suffix wrong: expected \"\", got \""
+ + thaiCurrency.getPositiveSuffix() + "\"");
+ }
}
/**
@@ -778,26 +845,25 @@
* iterate through all locales.
*/
public void TestEuroSupport() {
- final String EURO_VARIANT = "EURO";
+ final String EURO_VARIANT = "EURO";
final String EURO_CURRENCY = "\u20AC"; // Look for this string in formatted Euro currency
Locale[] locales = NumberFormat.getAvailableLocales();
- for (int i=0; i<locales.length; ++i) {
+ for (int i = 0; i < locales.length; ++i) {
Locale loc = locales[i];
if (loc.getVariant().indexOf(EURO_VARIANT) >= 0) {
NumberFormat nf = NumberFormat.getCurrencyInstance(loc);
String pos = nf.format(271828.182845);
String neg = nf.format(-271828.182845);
- if (pos.indexOf(EURO_CURRENCY) >= 0 &&
- neg.indexOf(EURO_CURRENCY) >= 0) {
- logln("Ok: " + loc.toString() +
- ": " + pos + " / " + neg);
- }
- else {
- errln("Fail: " + loc.toString() +
- " formats without " + EURO_CURRENCY +
- ": " + pos + " / " + neg +
- "\n*** THIS FAILURE MAY ONLY MEAN THAT LOCALE DATA HAS CHANGED ***");
+ if (pos.indexOf(EURO_CURRENCY) >= 0
+ && neg.indexOf(EURO_CURRENCY) >= 0) {
+ logln("Ok: " + loc.toString()
+ + ": " + pos + " / " + neg);
+ } else {
+ errln("Fail: " + loc.toString()
+ + " formats without " + EURO_CURRENCY
+ + ": " + pos + " / " + neg
+ + "\n*** THIS FAILURE MAY ONLY MEAN THAT LOCALE DATA HAS CHANGED ***");
}
}
}
@@ -811,15 +877,15 @@
Object[] DATA = {
new Locale("xx", "", ""), "xx",
new Locale("", "YY", ""), "_YY",
- new Locale("", "", "ZZ"), "",
+ new Locale("", "", "ZZ"), "",
new Locale("xx", "YY", ""), "xx_YY",
new Locale("xx", "", "ZZ"), "xx__ZZ",
new Locale("", "YY", "ZZ"), "_YY_ZZ",
new Locale("xx", "YY", "ZZ"), "xx_YY_ZZ",
};
- for (int i=0; i<DATA.length; i+=2) {
- Locale loc = (Locale)DATA[i];
- String fmt = (String)DATA[i+1];
+ for (int i = 0; i < DATA.length; i += 2) {
+ Locale loc = (Locale) DATA[i];
+ String fmt = (String) DATA[i + 1];
if (!loc.toString().equals(fmt)) {
errln("Fail: Locale.toString(" + fmt + ")=>" + loc);
}
@@ -832,9 +898,9 @@
* end to test the whole pipe.
*/
public void Test4105828() {
- Locale[] LOC = { Locale.CHINESE, new Locale("zh", "CN", ""),
- new Locale("zh", "TW", ""), new Locale("zh", "HK", "") };
- for (int i=0; i<LOC.length; ++i) {
+ Locale[] LOC = {Locale.CHINESE, new Locale("zh", "CN", ""),
+ new Locale("zh", "TW", ""), new Locale("zh", "HK", "")};
+ for (int i = 0; i < LOC.length; ++i) {
NumberFormat fmt = NumberFormat.getPercentInstance(LOC[i]);
String result = fmt.format(1);
if (!result.equals("100%")) {
@@ -860,14 +926,16 @@
* test that here.
*/
public void Test4139940() {
- Locale mylocale=new Locale("hu", "", "");
- Date mydate = new Date(98,3,13); // A Monday
+ Locale mylocale = new Locale("hu", "", "");
+ @SuppressWarnings("deprecation")
+ Date mydate = new Date(98, 3, 13); // A Monday
DateFormat df_full = new SimpleDateFormat("EEEE", mylocale);
String str = df_full.format(mydate);
// Make sure that o circumflex (\u00F4) is NOT there, and
// o double acute (\u0151) IS.
- if (str.indexOf('\u0151') < 0 || str.indexOf('\u00F4') >= 0)
+ if (str.indexOf('\u0151') < 0 || str.indexOf('\u00F4') >= 0) {
errln("Fail: Monday in Hungarian is wrong");
+ }
}
/**
@@ -894,9 +962,10 @@
try {
String result = locale.getISO3Country();
- errln("ERROR: getISO3Country() returns: " + result +
- " for locale '" + locale + "' rather than exception" );
- } catch(MissingResourceException e) { }
+ errln("ERROR: getISO3Country() returns: " + result
+ + " for locale '" + locale + "' rather than exception");
+ } catch (MissingResourceException e) {
+ }
}
/**
@@ -912,8 +981,8 @@
String result = locale.getISO3Language();
if (!result.equals("aaa")) {
- errln("ERROR: getISO3Language() returns: " + result +
- " for locale '" + locale + "' rather than returning it as is" );
+ errln("ERROR: getISO3Language() returns: " + result
+ + " for locale '" + locale + "' rather than returning it as is");
}
// Try an invalid two letter language code, and check whether it
@@ -923,36 +992,39 @@
try {
result = locale.getISO3Language();
- errln("ERROR: getISO3Language() returns: " + result +
- " for locale '" + locale + "' rather than exception" );
- } catch(MissingResourceException e) { }
+ errln("ERROR: getISO3Language() returns: " + result
+ + " for locale '" + locale + "' rather than exception");
+ } catch (MissingResourceException e) {
+ }
}
/*
* @bug 4147552 4778440 8030696
*/
public void Test4147552() {
- Locale[] locales = { new Locale("no", "NO"), new Locale("no", "NO", "B"),
- new Locale("no", "NO", "NY"), new Locale("nb", "NO"),
- new Locale("nn", "NO") };
- String[] englishDisplayNames = { "Norwegian (Norway)",
- "Norwegian (Norway,Bokm\u00e5l)",
- "Norwegian (Norway,Nynorsk)",
- "Norwegian Bokm\u00e5l (Norway)",
- "Norwegian Nynorsk (Norway)" };
- String[] norwegianDisplayNames = { "norsk (Norge)",
- "norsk (Norge,bokm\u00e5l)", "norsk (Noreg,nynorsk)",
- "bokm\u00e5l (Norge)", "nynorsk (Noreg)" };
+ Locale[] locales = {new Locale("no", "NO"), new Locale("no", "NO", "B"),
+ new Locale("no", "NO", "NY"), new Locale("nb", "NO"),
+ new Locale("nn", "NO")};
+ String[] englishDisplayNames = {"Norwegian (Norway)",
+ "Norwegian (Norway,Bokm\u00e5l)",
+ "Norwegian (Norway,Nynorsk)",
+ "Norwegian Bokm\u00e5l (Norway)",
+ "Norwegian Nynorsk (Norway)"};
+ String[] norwegianDisplayNames = {"norsk (Norge)",
+ "norsk (Norge,bokm\u00e5l)", "norsk (Noreg,nynorsk)",
+ "bokm\u00e5l (Norge)", "nynorsk (Noreg)"};
for (int i = 0; i < locales.length; i++) {
Locale loc = locales[i];
- if (!loc.getDisplayName(Locale.US).equals(englishDisplayNames[i]))
- errln("English display-name mismatch: expected " +
- englishDisplayNames[i] + ", got " + loc.getDisplayName());
- if (!loc.getDisplayName(loc).equals(norwegianDisplayNames[i]))
- errln("Norwegian display-name mismatch: expected " +
- norwegianDisplayNames[i] + ", got " +
- loc.getDisplayName(loc));
+ if (!loc.getDisplayName(Locale.US).equals(englishDisplayNames[i])) {
+ errln("English display-name mismatch: expected "
+ + englishDisplayNames[i] + ", got " + loc.getDisplayName());
+ }
+ if (!loc.getDisplayName(loc).equals(norwegianDisplayNames[i])) {
+ errln("Norwegian display-name mismatch: expected "
+ + norwegianDisplayNames[i] + ", got "
+ + loc.getDisplayName(loc));
+ }
}
}
@@ -961,21 +1033,24 @@
*/
public void Test8030696() {
List<Locale> av = Arrays.asList(Locale.getAvailableLocales());
- if (!av.contains(new Locale("nb", "NO")) ||
- !av.contains(new Locale("nn", "NO"))) {
- errln("\"nb-NO\" and/or \"nn-NO\" locale(s) not returned from getAvailableLocales().");
+ if (!av.contains(new Locale("nb", "NO"))
+ || !av.contains(new Locale("nn", "NO"))) {
+ errln("\"nb-NO\" and/or \"nn-NO\" locale(s) not returned from getAvailableLocales().");
}
}
static String escapeUnicode(String s) {
StringBuffer buf = new StringBuffer();
- for (int i=0; i<s.length(); ++i) {
+ for (int i = 0; i < s.length(); ++i) {
char c = s.charAt(i);
- if (c >= 0x20 && c <= 0x7F) buf.append(c);
- else {
+ if (c >= 0x20 && c <= 0x7F) {
+ buf.append(c);
+ } else {
buf.append("\\u");
String h = "000" + Integer.toHexString(c);
- if (h.length() > 4) h = h.substring(h.length() - 4);
+ if (h.length() > 4) {
+ h = h.substring(h.length() - 4);
+ }
buf.append(h);
}
}
--- a/jdk/test/java/util/Locale/LocaleTestFmwk.java Wed Nov 16 17:29:14 2016 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,267 +0,0 @@
-/*
- * Copyright (c) 2010, 2013, 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.
- */
-
-/*
- *
- *
- * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
- * (C) Copyright IBM Corp. 1996 - 1999 - All Rights Reserved
- *
- * Portions copyright (c) 2007 Sun Microsystems, Inc.
- * All Rights Reserved.
- *
- * The original version of this source code and documentation
- * is copyrighted and owned by Taligent, Inc., a wholly-owned
- * subsidiary of IBM. These materials are provided under terms
- * of a License Agreement between Taligent and Sun. This technology
- * is protected by multiple US and International patents.
- *
- * This notice and attribution to Taligent may not be removed.
- * Taligent is a registered trademark of Taligent, Inc.
- *
- * Permission to use, copy, modify, and distribute this software
- * and its documentation for NON-COMMERCIAL purposes and without
- * fee is hereby granted provided that this copyright notice
- * appears in all copies. Please refer to the file "copyright.html"
- * for further important copyright and licensing information.
- *
- * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
- * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
- * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
- * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
- * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
- *
- */
-
-import java.lang.reflect.*;
-import java.util.Hashtable;
-import java.util.Enumeration;
-import java.util.Vector;
-import java.io.*;
-import java.text.*;
-
-/**
- * LocaleTestFmwk is a base class for tests that can be run conveniently from
- * the command line as well as under the Java test harness.
- * <p>
- * Sub-classes implement a set of methods named Test<something>. Each
- * of these methods performs some test. Test methods should indicate
- * errors by calling either err or errln. This will increment the
- * errorCount field and may optionally print a message to the log.
- * Debugging information may also be added to the log via the log
- * and logln methods. These methods will add their arguments to the
- * log only if the test is being run in verbose mode.
- */
-public class LocaleTestFmwk {
- //------------------------------------------------------------------------
- // Everything below here is boilerplate code that makes it possible
- // to add a new test by simply adding a function to an existing class
- //------------------------------------------------------------------------
-
- protected LocaleTestFmwk() {
- // Create a hashtable containing all the test methods.
- testMethods = new Hashtable();
- Method[] methods = getClass().getDeclaredMethods();
- for( int i=0; i<methods.length; i++ ) {
- if( methods[i].getName().startsWith("Test")
- || methods[i].getName().startsWith("test")) {
- testMethods.put( methods[i].getName(), methods[i] );
- }
- }
- }
-
- protected void run(String[] args) throws Exception
- {
- System.out.println(getClass().getName() + " {");
- indentLevel++;
-
- // Set up the log and reference streams. We use PrintWriters in order to
- // take advantage of character conversion. The JavaEsc converter will
- // convert Unicode outside the ASCII range to Java's \\uxxxx notation.
- log = new PrintWriter(System.out,true);
-
- // Parse the test arguments. They can be either the flag
- // "-verbose" or names of test methods. Create a list of
- // tests to be run.
- Vector testsToRun = new Vector( args.length );
- for( int i=0; i<args.length; i++ ) {
- if( args[i].equals("-verbose") ) {
- verbose = true;
- }
- else if( args[i].equals("-prompt") ) {
- prompt = true;
- } else if (args[i].equals("-nothrow")) {
- nothrow = true;
- } else if (args[i].equals("-exitcode")) {
- exitcode = true;
- } else {
- Object m = testMethods.get( args[i] );
- if( m != null ) {
- testsToRun.addElement( m );
- }
- else {
- usage();
- return;
- }
- }
- }
-
- // If no test method names were given explicitly, run them all.
- if( testsToRun.size() == 0 ) {
- Enumeration methodNames = testMethods.elements();
- while( methodNames.hasMoreElements() ) {
- testsToRun.addElement( methodNames.nextElement() );
- }
- }
-
- // Run the list of tests given in the test arguments
- for( int i=0; i<testsToRun.size(); i++ ) {
- int oldCount = errorCount;
-
- Method testMethod = (Method)testsToRun.elementAt(i);
- writeTestName(testMethod.getName());
-
- try {
- testMethod.invoke(this, new Object[0]);
- }
- catch( IllegalAccessException e ) {
- errln("Can't acces test method " + testMethod.getName());
- }
- catch( InvocationTargetException e ) {
- errln("Uncaught exception thrown in test method "
- + testMethod.getName());
- e.getTargetException().printStackTrace(this.log);
- }
- writeTestResult(errorCount - oldCount);
- }
- indentLevel--;
- writeTestResult(errorCount);
-
- if (prompt) {
- System.out.println("Hit RETURN to exit...");
- try {
- System.in.read();
- }
- catch (IOException e) {
- System.out.println("Exception: " + e.toString() + e.getMessage());
- }
- }
- if (nothrow) {
- if (exitcode) {
- System.exit(errorCount);
- }
- if (errorCount > 0) {
- throw new IllegalArgumentException("encountered " + errorCount + " errors");
- }
- }
- }
-
- /**
- * Adds given string to the log if we are in verbose mode.
- */
- protected void log( String message ) {
- if( verbose ) {
- indent(indentLevel + 1);
- log.print( message );
- }
- }
-
- protected void logln( String message ) {
- log(message + System.getProperty("line.separator"));
- }
-
- /**
- * Report an error
- */
- protected void err( String message ) {
- errorCount++;
- indent(indentLevel + 1);
- log.print( message );
- log.flush();
-
- if (!nothrow) {
- throw new RuntimeException(message);
- }
- }
-
- protected void errln( String message ) {
- err(message + System.getProperty("line.separator"));
- }
-
-
- protected void writeTestName(String testName) {
- indent(indentLevel);
- log.print(testName);
- log.flush();
- needLineFeed = true;
- }
-
- protected void writeTestResult(int count) {
- if (!needLineFeed) {
- indent(indentLevel);
- log.print("}");
- }
- needLineFeed = false;
-
- if (count != 0)
- log.println(" FAILED");
- else
- log.println(" Passed");
- }
-
- private final void indent(int distance) {
- if (needLineFeed) {
- log.println(" {");
- needLineFeed = false;
- }
- log.print(spaces.substring(0, distance * 2));
- }
-
- /**
- * Print a usage message for this test class.
- */
- void usage() {
- System.out.println(getClass().getName() +
- ": [-verbose] [-nothrow] [-exitcode] [-prompt] [test names]");
-
- System.out.println("test names:");
- Enumeration methodNames = testMethods.keys();
- while( methodNames.hasMoreElements() ) {
- System.out.println("\t" + methodNames.nextElement() );
- }
- }
-
- private boolean prompt = false;
- private boolean nothrow = false;
- private boolean exitcode = false;
- protected boolean verbose = false;
-
- private PrintWriter log;
- private int indentLevel = 0;
- private boolean needLineFeed = false;
- private int errorCount = 0;
-
- private Hashtable testMethods;
- private final String spaces = " ";
-}