diff --git a/jdk/test/java/text/testlib/IntlTest.java b/jdk/test/java/text/testlib/IntlTest.java
index d8ae8572f30..9dfb5a45193 100644
--- a/jdk/test/java/text/testlib/IntlTest.java
+++ b/jdk/test/java/text/testlib/IntlTest.java
@@ -89,6 +89,9 @@ public abstract class IntlTest {
             case "-nothrow":
                 nothrow = true;
                 break;
+            case "-exitcode":
+                exitCode = true;
+                break;
             default:
                 Method m = testMethods.get(arg);
                 if (m == null) {
@@ -138,7 +141,12 @@ public abstract class IntlTest {
             }
         }
         if (nothrow) {
-            System.exit(errorCount);
+            if (exitCode) {
+                System.exit(errorCount);
+            }
+            if (errorCount > 0) {
+                throw new IllegalArgumentException("encountered " + errorCount + " errors");
+            }
         }
     }
 
@@ -243,7 +251,7 @@ public abstract class IntlTest {
      */
     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 @@ public abstract class IntlTest {
     private boolean     prompt;
     private boolean     nothrow;
     protected boolean   verbose;
-
+    private boolean     exitCode;
     private PrintWriter log;
     private int         indentLevel;
     private boolean     needLineFeed;
diff --git a/jdk/test/java/util/Calendar/Bug4766302.java b/jdk/test/java/util/Calendar/Bug4766302.java
index 42df92b7e16..cd27e009ea2 100644
--- a/jdk/test/java/util/Calendar/Bug4766302.java
+++ b/jdk/test/java/util/Calendar/Bug4766302.java
@@ -29,9 +29,11 @@
 
 import java.util.GregorianCalendar;
 
+@SuppressWarnings("serial")
 public class Bug4766302 {
 
     static class MyCalendar extends GregorianCalendar {
+
         boolean isTimeStillSet() {
             return isTimeSet;
         }
diff --git a/jdk/test/java/util/Calendar/Bug4958050.java b/jdk/test/java/util/Calendar/Bug4958050.java
index dfd627cda6f..2b2e6e4ff43 100644
--- a/jdk/test/java/util/Calendar/Bug4958050.java
+++ b/jdk/test/java/util/Calendar/Bug4958050.java
@@ -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 @@ public class Bug4958050 {
         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 @@ public class Bug4958050 {
             }
             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 @@ public class Bug4958050 {
         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 @@ public class Bug4958050 {
         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();
diff --git a/jdk/test/java/util/Calendar/CalendarRegression.java b/jdk/test/java/util/Calendar/CalendarRegression.java
index 2852fae33f6..8a1ebcc4544 100644
--- a/jdk/test/java/util/Calendar/CalendarRegression.java
+++ b/jdk/test/java/util/Calendar/CalendarRegression.java
@@ -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 @@ public class CalendarRegression extends IntlTest {
     }
 
     /*
-      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 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 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
+     */
     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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
         //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
+            } else {
                 break;
+            }
         }
         return cal.getTime();
     }
@@ -278,41 +296,47 @@ public class CalendarRegression extends IntlTest {
 
     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 @@ public class CalendarRegression extends IntlTest {
             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 @@ public class CalendarRegression extends IntlTest {
             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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
         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(Calendar.MONTH)+1)+"/"+
-                             gc.get(Calendar.DATE)+"/"+gc.get(Calendar.YEAR)+
-                             " + 1mo = ");
+        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 = ");
 
-            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 @@ public class CalendarRegression extends IntlTest {
             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 @@ public class CalendarRegression extends IntlTest {
         }
 
         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 @@ public class CalendarRegression extends IntlTest {
 
         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 @@ public class CalendarRegression extends IntlTest {
                 // 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 @@ public class CalendarRegression extends IntlTest {
         // 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 class CalendarRegression extends IntlTest {
     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 @@ public class CalendarRegression extends IntlTest {
             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 @@ public class CalendarRegression extends IntlTest {
                 // 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 @@ public class CalendarRegression extends IntlTest {
                 if (change != expectedChange) {
                     fail = true;
                     logln(" FAIL");
+                } else {
+                    logln(" OK");
                 }
-                else logln(" OK");
             }
         } finally {
             TimeZone.setDefault(saveZone);
@@ -852,10 +887,11 @@ public class CalendarRegression extends IntlTest {
      */
     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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
         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 class CalendarRegression extends IntlTest {
      */
     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 @@ public class CalendarRegression extends IntlTest {
 
         // 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 class CalendarRegression extends IntlTest {
      */
     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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
         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 class CalendarRegression extends IntlTest {
     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 @@ public class CalendarRegression extends IntlTest {
             "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 @@ public class CalendarRegression extends IntlTest {
      * 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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
                     errln("Fail: All three lines must match");
                 }
             }
-        }
-        finally {
+        } finally {
             TimeZone.setDefault(savedTz);
         }
     }
@@ -1174,14 +1212,14 @@ public class CalendarRegression extends IntlTest {
      * 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 class CalendarRegression extends IntlTest {
      */
     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 @@ public class CalendarRegression extends IntlTest {
      * 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 @@ public class CalendarRegression extends IntlTest {
                     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 @@ public class CalendarRegression extends IntlTest {
                 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 @@ public class CalendarRegression extends IntlTest {
                     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 @@ public class CalendarRegression extends IntlTest {
             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 @@ public class CalendarRegression extends IntlTest {
             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 @@ public class CalendarRegression extends IntlTest {
                                 }
                             }
 
-                            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 @@ public class CalendarRegression extends IntlTest {
                                     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 class CalendarRegression extends IntlTest {
     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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
         // 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 class CalendarRegression extends IntlTest {
      */
     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 @@ public class CalendarRegression extends IntlTest {
      *   DAY_OF_YEAR
      *   WEEK_OF_YEAR + DAY_OF_WEEK
      */
+    @SuppressWarnings("deprecation")
     public void Test4209071() {
         Calendar cal = Calendar.getInstance(Locale.US);
 
@@ -1524,106 +1559,104 @@ public class CalendarRegression extends IntlTest {
             // 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 @@ public class CalendarRegression extends IntlTest {
             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 @@ public class CalendarRegression extends IntlTest {
 
         // 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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
 
                 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 @@ public class CalendarRegression extends IntlTest {
      * 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 @@ public class CalendarRegression extends IntlTest {
      * 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 @@ public class CalendarRegression extends IntlTest {
         }
 
         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 @@ public class CalendarRegression extends IntlTest {
             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 @@ public class CalendarRegression extends IntlTest {
             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 @@ public class CalendarRegression extends IntlTest {
         // 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 @@ public class CalendarRegression extends IntlTest {
         }
         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 @@ public class CalendarRegression extends IntlTest {
 
         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 class CalendarRegression extends IntlTest {
      */
     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 class CalendarRegression extends IntlTest {
     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 @@ public class CalendarRegression extends IntlTest {
             errln("Wrong BCE and/or CE values");
         }
     }
-    */
-
+     */
     /**
      * 4167995: GregorianCalendar.setGregorianChange() not to spec
      */
@@ -2000,42 +2025,42 @@ public class CalendarRegression extends IntlTest {
         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 class CalendarRegression extends IntlTest {
     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 @@ public class CalendarRegression extends IntlTest {
         // 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 class CalendarRegression extends IntlTest {
      */
     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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
         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 class CalendarRegression extends IntlTest {
     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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
         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 @@ public class CalendarRegression extends IntlTest {
             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 @@ public class CalendarRegression extends IntlTest {
      * 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 @@ public class CalendarRegression extends IntlTest {
             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 @@ public class CalendarRegression extends IntlTest {
     /**
      * 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 class CalendarRegression extends IntlTest {
     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 @@ public class CalendarRegression extends IntlTest {
         // 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 @@ public class CalendarRegression extends IntlTest {
      * 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 @@ public class CalendarRegression extends IntlTest {
         // 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 @@ public class CalendarRegression extends IntlTest {
         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 class CalendarRegression extends IntlTest {
      */
     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.");
         }
     }
 }
diff --git a/jdk/test/java/util/Calendar/CalendarTest.java b/jdk/test/java/util/Calendar/CalendarTest.java
index b04bb03a1fc..d9ce67196af 100644
--- a/jdk/test/java/util/Calendar/CalendarTest.java
+++ b/jdk/test/java/util/Calendar/CalendarTest.java
@@ -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 @@ public class CalendarTest extends IntlTest {
           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 @@ public class CalendarTest extends IntlTest {
      * 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 @@ public class CalendarTest extends IntlTest {
             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 @@ public class CalendarTest extends IntlTest {
                 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 @@ public class CalendarTest extends IntlTest {
         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 @@ public class CalendarTest extends IntlTest {
         }
 
         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 @@ public class CalendarTest extends IntlTest {
         }
 
         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 @@ public class CalendarTest extends IntlTest {
         // 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 class CalendarTest extends IntlTest {
     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 @@ public class CalendarTest extends IntlTest {
 
     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);
-
-        c.clear();
-        c.set(Calendar.YEAR, 1997);
-        c.set(Calendar.MONTH, Calendar.JUNE);
-        c.set(Calendar.DATE, 3);
-
-        verify765("1997 third day of June = ", c, 1997, Calendar.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.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;
+        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.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(MONTH, JUNE);
+            c.set(DATE, 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.WEEK_OF_MONTH, 1);
-        verify765("1997 Tuesday in week 1 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.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(DAY_OF_WEEK_IN_MONTH, 1);
+            verify765("1997 first Tuesday in 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(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.setLenient(true); // for 4944795
             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");
+            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.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(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(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);
+
+            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);
+            }
+
+            c.clear();
+            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);
         }
-        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) {
+        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);
+        } 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 @@ public class CalendarTest extends IntlTest {
         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 @@ public class CalendarTest extends IntlTest {
             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 @@ public class CalendarTest extends IntlTest {
 
             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 @@ public class CalendarTest extends IntlTest {
 
     // 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 @@ public class CalendarTest extends IntlTest {
         // - 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 @@ public class CalendarTest extends IntlTest {
         // - 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 @@ public class CalendarTest extends IntlTest {
         // - 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 @@ public class CalendarTest extends IntlTest {
                 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 @@ public class CalendarTest extends IntlTest {
     // 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 @@ public class CalendarTest extends IntlTest {
             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);
         }
diff --git a/jdk/test/java/util/Calendar/CalendarTypeTest.java b/jdk/test/java/util/Calendar/CalendarTypeTest.java
index ce36cd656b3..41bb87e7421 100644
--- a/jdk/test/java/util/Calendar/CalendarTypeTest.java
+++ b/jdk/test/java/util/Calendar/CalendarTypeTest.java
@@ -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 @@ public class CalendarTypeTest {
         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 @@ public class CalendarTypeTest {
         }
     }
 
+    @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.");
diff --git a/jdk/test/java/util/Calendar/FieldStateTest.java b/jdk/test/java/util/Calendar/FieldStateTest.java
index caa6f219a24..34ab9e8076d 100644
--- a/jdk/test/java/util/Calendar/FieldStateTest.java
+++ b/jdk/test/java/util/Calendar/FieldStateTest.java
@@ -144,8 +144,11 @@ public class FieldStateTest extends IntlTest {
         }
 
         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 @@ public class FieldStateTest extends IntlTest {
      * 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 @@ public class FieldStateTest extends IntlTest {
         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)) {
diff --git a/jdk/test/java/util/Calendar/GregorianCutoverTest.java b/jdk/test/java/util/Calendar/GregorianCutoverTest.java
index bd743ae19f6..a9b840a95b1 100644
--- a/jdk/test/java/util/Calendar/GregorianCutoverTest.java
+++ b/jdk/test/java/util/Calendar/GregorianCutoverTest.java
@@ -76,7 +76,9 @@ public class GregorianCutoverTest extends IntlTest {
         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 @@ public class GregorianCutoverTest extends IntlTest {
 
         // 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 class GregorianCutoverTest extends IntlTest {
     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 @@ public class GregorianCutoverTest extends IntlTest {
         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 @@ public class GregorianCutoverTest extends IntlTest {
 
         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 @@ public class GregorianCutoverTest extends IntlTest {
         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());
         }
     }
diff --git a/jdk/test/java/util/Calendar/JavatimeTest.java b/jdk/test/java/util/Calendar/JavatimeTest.java
index 7af6e9d4c03..8f32801a307 100644
--- a/jdk/test/java/util/Calendar/JavatimeTest.java
+++ b/jdk/test/java/util/Calendar/JavatimeTest.java
@@ -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.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;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Random;
+import java.util.TimeZone;
 
 public class JavatimeTest {
 
@@ -46,10 +46,11 @@ public class JavatimeTest {
     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 @@ public class JavatimeTest {
             ///////////// 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 @@ public class JavatimeTest {
             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 @@ public class JavatimeTest {
             }
             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 @@ public class JavatimeTest {
         ///////////// 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 @@ public class JavatimeTest {
             }
             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);
             }
         }
diff --git a/jdk/test/java/util/Calendar/Koyomi.java b/jdk/test/java/util/Calendar/Koyomi.java
index 8eec03b5de4..90f2eda0867 100644
--- a/jdk/test/java/util/Calendar/Koyomi.java
+++ b/jdk/test/java/util/Calendar/Koyomi.java
@@ -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 @@ import java.util.TimeZone;
 /**
  * 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 @@ public class Koyomi extends GregorianCalendar {
         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 @@ public class Koyomi extends GregorianCalendar {
         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 @@ public class Koyomi extends GregorianCalendar {
     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 @@ public class Koyomi extends GregorianCalendar {
     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 @@ public class Koyomi extends GregorianCalendar {
     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 @@ public class Koyomi extends GregorianCalendar {
     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 @@ public class Koyomi extends GregorianCalendar {
     }
 
     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 @@ public class Koyomi extends GregorianCalendar {
     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 @@ public class Koyomi extends GregorianCalendar {
     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;
diff --git a/jdk/test/java/util/Calendar/NonLenientTest.java b/jdk/test/java/util/Calendar/NonLenientTest.java
index 6c42c594932..357cf0e95c0 100644
--- a/jdk/test/java/util/Calendar/NonLenientTest.java
+++ b/jdk/test/java/util/Calendar/NonLenientTest.java
@@ -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 @@ public class NonLenientTest extends IntlTest {
         validate(cal, "6th Sunday in Jan 2003");
     }
 
-
     /**
      * 4726030: GregorianCalendar doesn't check invalid dates in non-lenient
      */
@@ -146,34 +148,34 @@ public class NonLenientTest extends IntlTest {
      */
     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 @@ public class NonLenientTest extends IntlTest {
         // 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));
         }
     }
 
diff --git a/jdk/test/java/util/Calendar/ZoneOffsets.java b/jdk/test/java/util/Calendar/ZoneOffsets.java
index 147df337497..a0ddfde625c 100644
--- a/jdk/test/java/util/Calendar/ZoneOffsets.java
+++ b/jdk/test/java/util/Calendar/ZoneOffsets.java
@@ -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 class ZoneOffsets {
         }
 
         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 @@ public class ZoneOffsets {
     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 @@ public class ZoneOffsets {
 
     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 @@ public class ZoneOffsets {
     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());
     }
 }
diff --git a/jdk/test/java/util/Calendar/bug4372743.java b/jdk/test/java/util/Calendar/bug4372743.java
index 1800ebc002a..6d380e523e2 100644
--- a/jdk/test/java/util/Calendar/bug4372743.java
+++ b/jdk/test/java/util/Calendar/bug4372743.java
@@ -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 @@ public class bug4372743 extends IntlTest {
     }
 
     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 @@ public class bug4372743 extends IntlTest {
             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);
         }
     }
diff --git a/jdk/test/java/util/Calendar/bug4401223.java b/jdk/test/java/util/Calendar/bug4401223.java
index fbd9e29a8f6..3123181e1a1 100644
--- a/jdk/test/java/util/Calendar/bug4401223.java
+++ b/jdk/test/java/util/Calendar/bug4401223.java
@@ -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 @@ public class bug4401223 extends IntlTest {
         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 @@ public class bug4401223 extends IntlTest {
         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 {
diff --git a/jdk/test/java/util/Calendar/bug4514831.java b/jdk/test/java/util/Calendar/bug4514831.java
index 9d635e26167..f0c34a8aa2a 100644
--- a/jdk/test/java/util/Calendar/bug4514831.java
+++ b/jdk/test/java/util/Calendar/bug4514831.java
@@ -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 @@ public class bug4514831 {
         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);
diff --git a/jdk/test/java/util/Date/Bug4955000.java b/jdk/test/java/util/Date/Bug4955000.java
index c94b23868ca..4339f848f58 100644
--- a/jdk/test/java/util/Date/Bug4955000.java
+++ b/jdk/test/java/util/Date/Bug4955000.java
@@ -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 @@ public class Bug4955000 {
             };
             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 @@ public class Bug4955000 {
                 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 @@ public class Bug4955000 {
                                     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 @@ public class Bug4955000 {
 
                                     if (expected != result) {
                                         throw new RuntimeException("expected (" + expected
-                                                                   + ") != result (" + result +")");
+                                                + ") != result (" + result + ")");
                                     }
                                 }
                             }
diff --git a/jdk/test/java/util/Locale/Bug4175998Test.java b/jdk/test/java/util/Locale/Bug4175998Test.java
index e890ae9e667..a5ad1dd3abd 100644
--- a/jdk/test/java/util/Locale/Bug4175998Test.java
+++ b/jdk/test/java/util/Locale/Bug4175998Test.java
@@ -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
diff --git a/jdk/test/java/util/Locale/Bug4184873Test.java b/jdk/test/java/util/Locale/Bug4184873Test.java
index 478a67fbf8b..3dadf1fe3a9 100644
--- a/jdk/test/java/util/Locale/Bug4184873Test.java
+++ b/jdk/test/java/util/Locale/Bug4184873Test.java
@@ -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 @@ import java.io.*;
 /**
  *  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();
diff --git a/jdk/test/java/util/Locale/Bug8001562.java b/jdk/test/java/util/Locale/Bug8001562.java
index 1a18ac58a97..be53600a84d 100644
--- a/jdk/test/java/util/Locale/Bug8001562.java
+++ b/jdk/test/java/util/Locale/Bug8001562.java
@@ -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 @@ public class Bug8001562 {
         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 @@ public class Bug8001562 {
         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);
diff --git a/jdk/test/java/util/Locale/HashCodeTest.java b/jdk/test/java/util/Locale/HashCodeTest.java
index 8163ca03dc3..a911515274f 100644
--- a/jdk/test/java/util/Locale/HashCodeTest.java
+++ b/jdk/test/java/util/Locale/HashCodeTest.java
@@ -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 @@ public class HashCodeTest {
             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");
         }
     }
 }
diff --git a/jdk/test/java/util/Locale/LocaleEnhanceTest.java b/jdk/test/java/util/Locale/LocaleEnhanceTest.java
index a4a2f1106fc..c30804d3a15 100644
--- a/jdk/test/java/util/Locale/LocaleEnhanceTest.java
+++ b/jdk/test/java/util/Locale/LocaleEnhanceTest.java
@@ -46,11 +46,12 @@ import java.util.Set;
  * @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>();
diff --git a/jdk/test/java/util/Locale/LocaleTest.java b/jdk/test/java/util/Locale/LocaleTest.java
index 90510ce2fda..33fd411863a 100644
--- a/jdk/test/java/util/Locale/LocaleTest.java
+++ b/jdk/test/java/util/Locale/LocaleTest.java
@@ -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 @@ public class LocaleTest extends LocaleTestFmwk {
             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 @@ public class LocaleTest extends LocaleTestFmwk {
             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 @@ public class LocaleTest extends LocaleTestFmwk {
      * @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 @@ public class LocaleTest extends LocaleTestFmwk {
     }
 
     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 @@ public class LocaleTest extends LocaleTestFmwk {
 
         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 @@ public class LocaleTest extends LocaleTestFmwk {
         //     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 @@ public class LocaleTest extends LocaleTestFmwk {
         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 class LocaleTest extends LocaleTestFmwk {
      */
     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 class LocaleTest extends LocaleTestFmwk {
     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 @@ test commented out pending API-change approval
      * @bug 4110613
      */
     public void TestSerialization() throws ClassNotFoundException, OptionalDataException,
-                    IOException, StreamCorruptedException
-    {
+            IOException, StreamCorruptedException {
         ObjectOutputStream ostream;
         ByteArrayOutputStream obstream;
         byte[] bytes = null;
@@ -565,10 +619,11 @@ test commented out pending API-change approval
 
         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 @@ test commented out pending API-change approval
         // 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 @@ test commented out pending API-change approval
     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 @@ test commented out pending API-change approval
         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 @@ test commented out pending API-change approval
         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 @@ test commented out pending API-change approval
         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 @@ test commented out pending API-change approval
      * 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 @@ test commented out pending API-change approval
      * 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 @@ test commented out pending API-change approval
         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 @@ test commented out pending API-change approval
      * 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 commented out pending API-change approval
      * 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 @@ test commented out pending API-change approval
         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 @@ test commented out pending API-change approval
 
         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 @@ test commented out pending API-change approval
         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 @@ test commented out pending API-change approval
      */
     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);
             }
         }
diff --git a/jdk/test/java/util/Locale/LocaleTestFmwk.java b/jdk/test/java/util/Locale/LocaleTestFmwk.java
deleted file mode 100644
index 68532d4d31d..00000000000
--- a/jdk/test/java/util/Locale/LocaleTestFmwk.java
+++ /dev/null
@@ -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 = "                                          ";
-}