Fix some warnings in Eclipse

javatests/org/chromium/distiller/AssertTest.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.distiller;
 
 public class AssertTest extends JsTestCase {
     private static class CheckFailedException extends RuntimeException {
     }
 
@@ skipping 23 matching lines @@
             throw new CheckFailedException();
         }
 
         if (checker.test(true) != expectSuccess) {
             throw new CheckFailedException();
         }
     }
 
     public void testCheck() {
         Checker passer = new Checker() {
+            @Override
             void run(boolean withMessage) {
             }
         };
         Checker failer = new Checker() {
+            @Override
             void run(boolean withMessage) {
                 fail();
             }
         };
 
         // These should not throw exceptions.
         check(true, passer);
         check(false, failer);
 
         // Each of these should fail.
         try {
             check(false, passer);
             fail();
         } catch (CheckFailedException e) {
         }
 
         try {
             check(true, failer);
             fail();
         } catch (CheckFailedException e) {
         }
 
         // A Checker's success/failure is expected to be consistent across null/non-null messages.
         // If not, check should fail regardless of the expectedSuccess value.
         Checker nullFailer = new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (!withMessage) fail();
             }
         };
         Checker stringFailer = new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) fail();
             }
         };
 
         try {
             check(true, nullFailer);
             fail();
         } catch (CheckFailedException e) {
         }
@@ skipping 14 matching lines @@
             check(false, stringFailer);
             fail();
         } catch (CheckFailedException e) {
         }
     }
 
     private static void checkArrayEquals(boolean expectSuccess,
             final char[] expecteds,
             final char[] actuals) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertArrayEquals("", expecteds, actuals);
                 } else {
                     assertArrayEquals(expecteds, actuals);
                 }
             }
         });
     }
 
     private static void checkArrayEquals(boolean expectSuccess,
             final byte[] expecteds,
             final byte[] actuals) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertArrayEquals("", expecteds, actuals);
                 } else {
                     assertArrayEquals(expecteds, actuals);
                 }
             }
         });
     }
 
     private static void checkArrayEquals(boolean expectSuccess,
             final short[] expecteds,
             final short[] actuals) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertArrayEquals("", expecteds, actuals);
                 } else {
                     assertArrayEquals(expecteds, actuals);
                 }
             }
         });
     }
 
     private static void checkArrayEquals(boolean expectSuccess,
             final int[] expecteds,
             final int[] actuals) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertArrayEquals("", expecteds, actuals);
                 } else {
                     assertArrayEquals(expecteds, actuals);
                 }
             }
         });
     }
 
     private static void checkArrayEquals(boolean expectSuccess,
             final long[] expecteds,
             final long[] actuals) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertArrayEquals("", expecteds, actuals);
                 } else {
                     assertArrayEquals(expecteds, actuals);
                 }
             }
         });
     }
 
     private static void checkArrayEquals(boolean expectSuccess,
             final Object[] expecteds,
             final Object[] actuals) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertArrayEquals("", expecteds, actuals);
                 } else {
                     assertArrayEquals(expecteds, actuals);
                 }
             }
         });
     }
 
     private static void checkEquals(boolean expectSuccess,
             final double expected,
             final double actual,
             final double delta) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertEquals("", expected, actual, delta);
                 } else {
                     assertEquals(expected, actual, delta);
                 }
             }
         });
     }
 
     private static void checkEquals(boolean expectSuccess,
             final long expected,
             final long actual) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertEquals("", expected, actual);
                 } else {
                     assertEquals(expected, actual);
                 }
             }
         });
     }
 
     private static void checkEquals(boolean expectSuccess,
             final Object expected,
             final Object actual) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertEquals("", expected, actual);
                 } else {
                     assertEquals(expected, actual);
                 }
             }
         });
     }
 
     private static void checkAssertFalse(boolean expectSuccess,
             final boolean value) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertFalse("", value);
                 } else {
                     assertFalse(value);
                 }
             }
         });
     }
 
     private static void checkAssertTrue(boolean expectSuccess,
             final boolean value) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertTrue("", value);
                 } else {
                     assertTrue(value);
                 }
             }
         });
     }
 
 
     private static void checkAssertNull(boolean expectSuccess,
             final Object value) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertNull("", value);
                 } else {
                     assertNull(value);
                 }
             }
         });
     }
 
     private static void checkAssertNotNull(boolean expectSuccess,
             final Object value) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertNotNull("", value);
                 } else {
                     assertNotNull(value);
                 }
             }
         });
     }
 
     private static void checkAssertSame(boolean expectSuccess,
             final Object expected,
             final Object actual) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertSame("", expected, actual);
                 } else {
                     assertSame(expected, actual);
                 }
             }
         });
     }
 
     private static void checkAssertNotSame(boolean expectSuccess,
             final Object expected,
             final Object actual) {
         check(expectSuccess, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     assertNotSame("", expected, actual);
                 } else {
                     assertNotSame(expected, actual);
                 }
             }
         });
     }
 
@@ skipping 145 matching lines @@
         assertTrue(v.equals(o));
         checkAssertNotSame(false, v, v);
         checkAssertNotSame(false, null, null);
         checkAssertNotSame(false, "", "");
         checkAssertNotSame(true, v, "");
         checkAssertNotSame(true, v, o);
     }
 
     public void testFail() {
         check(false, new Checker() {
+            @Override
             void run(boolean withMessage) {
                 if (withMessage) {
                     fail("");
                 } else {
                     fail();
                 }
             }
         });
     }
 }