diff --git a/google3/third_party/java_src/junit/LICENSE b/google3/third_party/java_src/junit/LICENSE
new file mode 100644
index 0000000..fb68629
--- /dev/null
+++ b/google3/third_party/java_src/junit/LICENSE
@@ -0,0 +1,214 @@
+JUnit
+
+Eclipse Public License - v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
+LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
+CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+      a) in the case of the initial Contributor, the initial code and
+         documentation distributed under this Agreement, and
+      b) in the case of each subsequent Contributor:
+
+      i) changes to the Program, and
+
+      ii) additions to the Program;
+
+      where such changes and/or additions to the Program originate from and are
+distributed by that particular Contributor. A Contribution 'originates' from a
+Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to
+the Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii) are
+not derivative works of the Program. 
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are
+necessarily infringed by the use or sale of its Contribution alone or when
+combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement,
+including all Contributors.
+
+2. GRANT OF RIGHTS
+
+      a) Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide, royalty-free copyright license to
+reproduce, prepare derivative works of, publicly display, publicly perform,
+distribute and sublicense the Contribution of such Contributor, if any, and
+such derivative works, in source code and object code form.
+
+      b) Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide, royalty-free patent license under
+Licensed Patents to make, use, sell, offer to sell, import and otherwise
+transfer the Contribution of such Contributor, if any, in source code and
+object code form. This patent license shall apply to the combination of the
+Contribution and the Program if, at the time the Contribution is added by the
+Contributor, such addition of the Contribution causes such combination to be
+covered by the Licensed Patents. The patent license shall not apply to any
+other combinations which include the Contribution. No hardware per se is
+licensed hereunder. 
+
+      c) Recipient understands that although each Contributor grants the
+licenses to its Contributions set forth herein, no assurances are provided by
+any Contributor that the Program does not infringe the patent or other
+intellectual property rights of any other entity. Each Contributor disclaims
+any liability to Recipient for claims brought by any other entity based on
+infringement of intellectual property rights or otherwise. As a condition to
+exercising the rights and licenses granted hereunder, each Recipient hereby
+assumes sole responsibility to secure any other intellectual property rights
+needed, if any. For example, if a third party patent license is required to
+allow Recipient to distribute the Program, it is Recipient's responsibility to
+acquire that license before distributing the Program.
+
+      d) Each Contributor represents that to its knowledge it has sufficient
+copyright rights in its Contribution, if any, to grant the copyright license
+set forth in this Agreement. 
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under
+its own license agreement, provided that:
+
+      a) it complies with the terms and conditions of this Agreement; and
+
+      b) its license agreement:
+
+      i) effectively disclaims on behalf of all Contributors all warranties and
+conditions, express and implied, including warranties or conditions of title
+and non-infringement, and implied warranties or conditions of merchantability
+and fitness for a particular purpose; 
+
+      ii) effectively excludes on behalf of all Contributors all liability for
+damages, including direct, indirect, special, incidental and consequential
+damages, such as lost profits; 
+
+      iii) states that any provisions which differ from this Agreement are
+offered by that Contributor alone and not by any other party; and
+
+      iv) states that source code for the Program is available from such
+Contributor, and informs licensees how to obtain it in a reasonable manner on
+or through a medium customarily used for software exchange. 
+
+When the Program is made available in source code form:
+
+      a) it must be made available under this Agreement; and 
+
+      b) a copy of this Agreement must be included with each copy of the
+Program. 
+
+Contributors may not remove or alter any copyright notices contained within the
+Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if
+any, in a manner that reasonably allows subsequent Recipients to identify the
+originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with
+respect to end users, business partners and the like. While this license is
+intended to facilitate the commercial use of the Program, the Contributor who
+includes the Program in a commercial product offering should do so in a manner
+which does not create potential liability for other Contributors. Therefore, if
+a Contributor includes the Program in a commercial product offering, such
+Contributor ("Commercial Contributor") hereby agrees to defend and indemnify
+every other Contributor ("Indemnified Contributor") against any losses, damages
+and costs (collectively "Losses") arising from claims, lawsuits and other legal
+actions brought by a third party against the Indemnified Contributor to the
+extent caused by the acts or omissions of such Commercial Contributor in
+connection with its distribution of the Program in a commercial product
+offering. The obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In order
+to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor
+to control, and cooperate with the Commercial Contributor in, the defense and
+any related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product
+offering, Product X. That Contributor is then a Commercial Contributor. If that
+Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such
+Commercial Contributor's responsibility alone. Under this section, the
+Commercial Contributor would have to defend claims against the other
+Contributors related to those performance claims and warranties, and if a court
+requires any other Contributor to pay any damages as a result, the Commercial
+Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
+Recipient is solely responsible for determining the appropriateness of using
+and distributing the Program and assumes all risks associated with its exercise
+of rights under this Agreement, including but not limited to the risks and
+costs of program errors, compliance with applicable laws, damage to or loss of
+data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
+CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable
+law, it shall not affect the validity or enforceability of the remainder of the
+terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such
+provision valid and enforceable.
+
+If Recipient institutes patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other software or
+hardware) infringes such Recipient's patent(s), then such Recipient's rights
+granted under Section 2(b) shall terminate as of the date such litigation is
+filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to
+comply with any of the material terms or conditions of this Agreement and does
+not cure such failure in a reasonable period of time after becoming aware of
+such noncompliance. If all Recipient's rights under this Agreement terminate,
+Recipient agrees to cease use and distribution of the Program as soon as
+reasonably practicable. However, Recipient's obligations under this Agreement
+and any licenses granted by Recipient relating to the Program shall continue
+and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in
+order to avoid inconsistency the Agreement is copyrighted and may only be
+modified in the following manner. The Agreement Steward reserves the right to
+publish new versions (including revisions) of this Agreement from time to time.
+No one other than the Agreement Steward has the right to modify this Agreement.
+The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to
+serve as the Agreement Steward to a suitable separate entity. Each new version
+of the Agreement will be given a distinguishing version number. The Program
+(including Contributions) may always be distributed subject to the version of
+the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program
+(including its Contributions) under the new version. Except as expressly stated
+in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether
+expressly, by implication, estoppel or otherwise. All rights in the Program not
+expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the
+intellectual property laws of the United States of America. No party to this
+Agreement will bring a legal action under this Agreement more than one year
+after the cause of action arose. Each party waives its rights to a jury trial
+in any resulting litigation. 
+
diff --git a/google3/third_party/java_src/junit/main/java/junit/extensions/ActiveTestSuite.java b/google3/third_party/java_src/junit/main/java/junit/extensions/ActiveTestSuite.java
new file mode 100644
index 0000000..6f0f99d
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/extensions/ActiveTestSuite.java
@@ -0,0 +1,70 @@
+package junit.extensions;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+
+/**
+ * A TestSuite for active Tests. It runs each
+ * test in a separate thread and waits until all
+ * threads have terminated.
+ * -- Aarhus Radisson Scandinavian Center 11th floor
+ */
+public class ActiveTestSuite extends TestSuite {
+    private volatile int fActiveTestDeathCount;
+
+    public ActiveTestSuite() {
+    }
+
+    public ActiveTestSuite(Class<? extends TestCase> theClass) {
+        super(theClass);
+    }
+
+    public ActiveTestSuite(String name) {
+        super(name);
+    }
+
+    public ActiveTestSuite(Class<? extends TestCase> theClass, String name) {
+        super(theClass, name);
+    }
+
+    @Override
+    public void run(TestResult result) {
+        fActiveTestDeathCount = 0;
+        super.run(result);
+        waitUntilFinished();
+    }
+
+    @Override
+    public void runTest(final Test test, final TestResult result) {
+        Thread t = new Thread() {
+            @Override
+            public void run() {
+                try {
+                    // inlined due to limitation in VA/Java
+                    //ActiveTestSuite.super.runTest(test, result);
+                    test.run(result);
+                } finally {
+                    ActiveTestSuite.this.runFinished();
+                }
+            }
+        };
+        t.start();
+    }
+
+    synchronized void waitUntilFinished() {
+        while (fActiveTestDeathCount < testCount()) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                return; // ignore
+            }
+        }
+    }
+
+    public synchronized void runFinished() {
+        fActiveTestDeathCount++;
+        notifyAll();
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/extensions/RepeatedTest.java b/google3/third_party/java_src/junit/main/java/junit/extensions/RepeatedTest.java
new file mode 100644
index 0000000..22c690a
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/extensions/RepeatedTest.java
@@ -0,0 +1,39 @@
+package junit.extensions;
+
+import junit.framework.Test;
+import junit.framework.TestResult;
+
+/**
+ * A Decorator that runs a test repeatedly.
+ */
+public class RepeatedTest extends TestDecorator {
+    private int fTimesRepeat;
+
+    public RepeatedTest(Test test, int repeat) {
+        super(test);
+        if (repeat < 0) {
+            throw new IllegalArgumentException("Repetition count must be >= 0");
+        }
+        fTimesRepeat = repeat;
+    }
+
+    @Override
+    public int countTestCases() {
+        return super.countTestCases() * fTimesRepeat;
+    }
+
+    @Override
+    public void run(TestResult result) {
+        for (int i = 0; i < fTimesRepeat; i++) {
+            if (result.shouldStop()) {
+                break;
+            }
+            super.run(result);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + "(repeated)";
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/extensions/TestDecorator.java b/google3/third_party/java_src/junit/main/java/junit/extensions/TestDecorator.java
new file mode 100644
index 0000000..a3c5e08
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/extensions/TestDecorator.java
@@ -0,0 +1,43 @@
+package junit.extensions;
+
+import junit.framework.Assert;
+import junit.framework.Test;
+import junit.framework.TestResult;
+
+/**
+ * A Decorator for Tests. Use TestDecorator as the base class for defining new
+ * test decorators. Test decorator subclasses can be introduced to add behaviour
+ * before or after a test is run.
+ */
+@SuppressWarnings("deprecation")
+public class TestDecorator extends Assert implements Test {
+    protected Test fTest;
+
+    public TestDecorator(Test test) {
+        fTest = test;
+    }
+
+    /**
+     * The basic run behaviour.
+     */
+    public void basicRun(TestResult result) {
+        fTest.run(result);
+    }
+
+    public int countTestCases() {
+        return fTest.countTestCases();
+    }
+
+    public void run(TestResult result) {
+        basicRun(result);
+    }
+
+    @Override
+    public String toString() {
+        return fTest.toString();
+    }
+
+    public Test getTest() {
+        return fTest;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/extensions/TestSetup.java b/google3/third_party/java_src/junit/main/java/junit/extensions/TestSetup.java
new file mode 100644
index 0000000..fcdca8c
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/extensions/TestSetup.java
@@ -0,0 +1,42 @@
+package junit.extensions;
+
+import junit.framework.Protectable;
+import junit.framework.Test;
+import junit.framework.TestResult;
+
+/**
+ * A Decorator to set up and tear down additional fixture state. Subclass
+ * TestSetup and insert it into your tests when you want to set up additional
+ * state once before the tests are run.
+ */
+public class TestSetup extends TestDecorator {
+
+    public TestSetup(Test test) {
+        super(test);
+    }
+
+    @Override
+    public void run(final TestResult result) {
+        Protectable p = new Protectable() {
+            public void protect() throws Exception {
+                setUp();
+                basicRun(result);
+                tearDown();
+            }
+        };
+        result.runProtected(this, p);
+    }
+
+    /**
+     * Sets up the fixture. Override to set up additional fixture state.
+     */
+    protected void setUp() throws Exception {
+    }
+
+    /**
+     * Tears down the fixture. Override to tear down the additional fixture
+     * state.
+     */
+    protected void tearDown() throws Exception {
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/extensions/package-info.java b/google3/third_party/java_src/junit/main/java/junit/extensions/package-info.java
new file mode 100644
index 0000000..a1c5bb4
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/extensions/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Provides extended functionality for JUnit v3.x.
+ */
+package junit.extensions;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/Assert.java b/google3/third_party/java_src/junit/main/java/junit/framework/Assert.java
new file mode 100644
index 0000000..43482a1
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/Assert.java
@@ -0,0 +1,339 @@
+package junit.framework;
+
+/**
+ * A set of assert methods.  Messages are only displayed when an assert fails.
+ *
+ * @deprecated Please use {@link org.junit.Assert} instead.
+ */
+@Deprecated
+public class Assert {
+    /**
+     * Protect constructor since it is a static only class
+     */
+    protected Assert() {
+    }
+
+    /**
+     * Asserts that a condition is true. If it isn't it throws
+     * an AssertionFailedError with the given message.
+     */
+    public static void assertTrue(String message, boolean condition) {
+        if (!condition) {
+            fail(message);
+        }
+    }
+
+    /**
+     * Asserts that a condition is true. If it isn't it throws
+     * an AssertionFailedError.
+     */
+    public static void assertTrue(boolean condition) {
+        assertTrue(null, condition);
+    }
+
+    /**
+     * Asserts that a condition is false. If it isn't it throws
+     * an AssertionFailedError with the given message.
+     */
+    public static void assertFalse(String message, boolean condition) {
+        assertTrue(message, !condition);
+    }
+
+    /**
+     * Asserts that a condition is false. If it isn't it throws
+     * an AssertionFailedError.
+     */
+    public static void assertFalse(boolean condition) {
+        assertFalse(null, condition);
+    }
+
+    /**
+     * Fails a test with the given message.
+     */
+    public static void fail(String message) {
+        if (message == null) {
+            throw new AssertionFailedError();
+        }
+        throw new AssertionFailedError(message);
+    }
+
+    /**
+     * Fails a test with no message.
+     */
+    public static void fail() {
+        fail(null);
+    }
+
+    /**
+     * Asserts that two objects are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, Object expected, Object actual) {
+        if (expected == null && actual == null) {
+            return;
+        }
+        if (expected != null && expected.equals(actual)) {
+            return;
+        }
+        failNotEquals(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two objects are equal. If they are not
+     * an AssertionFailedError is thrown.
+     */
+    public static void assertEquals(Object expected, Object actual) {
+        assertEquals(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two Strings are equal.
+     */
+    public static void assertEquals(String message, String expected, String actual) {
+        if (expected == null && actual == null) {
+            return;
+        }
+        if (expected != null && expected.equals(actual)) {
+            return;
+        }
+        String cleanMessage = message == null ? "" : message;
+        throw new ComparisonFailure(cleanMessage, expected, actual);
+    }
+
+    /**
+     * Asserts that two Strings are equal.
+     */
+    public static void assertEquals(String expected, String actual) {
+        assertEquals(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two doubles are equal concerning a delta.  If they are not
+     * an AssertionFailedError is thrown with the given message.  If the expected
+     * value is infinity then the delta value is ignored.
+     */
+    public static void assertEquals(String message, double expected, double actual, double delta) {
+        if (Double.compare(expected, actual) == 0) {
+            return;
+        }
+        if (!(Math.abs(expected - actual) <= delta)) {
+            failNotEquals(message, Double.valueOf(expected), Double.valueOf(actual));
+        }
+    }
+
+    /**
+     * Asserts that two doubles are equal concerning a delta. If the expected
+     * value is infinity then the delta value is ignored.
+     */
+    public static void assertEquals(double expected, double actual, double delta) {
+        assertEquals(null, expected, actual, delta);
+    }
+
+    /**
+     * Asserts that two floats are equal concerning a positive delta. If they
+     * are not an AssertionFailedError is thrown with the given message. If the
+     * expected value is infinity then the delta value is ignored.
+     */
+    public static void assertEquals(String message, float expected, float actual, float delta) {
+        if (Float.compare(expected, actual) == 0) {
+            return;
+        }
+        if (!(Math.abs(expected - actual) <= delta)) {
+            failNotEquals(message, Float.valueOf(expected), Float.valueOf(actual));
+        }
+    }
+
+    /**
+     * Asserts that two floats are equal concerning a delta. If the expected
+     * value is infinity then the delta value is ignored.
+     */
+    public static void assertEquals(float expected, float actual, float delta) {
+        assertEquals(null, expected, actual, delta);
+    }
+
+    /**
+     * Asserts that two longs are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, long expected, long actual) {
+        assertEquals(message, Long.valueOf(expected), Long.valueOf(actual));
+    }
+
+    /**
+     * Asserts that two longs are equal.
+     */
+    public static void assertEquals(long expected, long actual) {
+        assertEquals(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two booleans are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, boolean expected, boolean actual) {
+        assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));
+    }
+
+    /**
+     * Asserts that two booleans are equal.
+     */
+    public static void assertEquals(boolean expected, boolean actual) {
+        assertEquals(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two bytes are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, byte expected, byte actual) {
+        assertEquals(message, Byte.valueOf(expected), Byte.valueOf(actual));
+    }
+
+    /**
+     * Asserts that two bytes are equal.
+     */
+    public static void assertEquals(byte expected, byte actual) {
+        assertEquals(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two chars are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, char expected, char actual) {
+        assertEquals(message, Character.valueOf(expected), Character.valueOf(actual));
+    }
+
+    /**
+     * Asserts that two chars are equal.
+     */
+    public static void assertEquals(char expected, char actual) {
+        assertEquals(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two shorts are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, short expected, short actual) {
+        assertEquals(message, Short.valueOf(expected), Short.valueOf(actual));
+    }
+
+    /**
+     * Asserts that two shorts are equal.
+     */
+    public static void assertEquals(short expected, short actual) {
+        assertEquals(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two ints are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, int expected, int actual) {
+        assertEquals(message, Integer.valueOf(expected), Integer.valueOf(actual));
+    }
+
+    /**
+     * Asserts that two ints are equal.
+     */
+    public static void assertEquals(int expected, int actual) {
+        assertEquals(null, expected, actual);
+    }
+
+    /**
+     * Asserts that an object isn't null.
+     */
+    public static void assertNotNull(Object object) {
+        assertNotNull(null, object);
+    }
+
+    /**
+     * Asserts that an object isn't null. If it is
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertNotNull(String message, Object object) {
+        assertTrue(message, object != null);
+    }
+
+    /**
+     * Asserts that an object is null. If it isn't an {@link AssertionError} is
+     * thrown.
+     * Message contains: Expected: <null> but was: object
+     *
+     * @param object Object to check or <code>null</code>
+     */
+    public static void assertNull(Object object) {
+        if (object != null) {
+            assertNull("Expected: <null> but was: " + object.toString(), object);
+        }
+    }
+
+    /**
+     * Asserts that an object is null.  If it is not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertNull(String message, Object object) {
+        assertTrue(message, object == null);
+    }
+
+    /**
+     * Asserts that two objects refer to the same object. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertSame(String message, Object expected, Object actual) {
+        if (expected == actual) {
+            return;
+        }
+        failNotSame(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two objects refer to the same object. If they are not
+     * the same an AssertionFailedError is thrown.
+     */
+    public static void assertSame(Object expected, Object actual) {
+        assertSame(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two objects do not refer to the same object. If they do
+     * refer to the same object an AssertionFailedError is thrown with the
+     * given message.
+     */
+    public static void assertNotSame(String message, Object expected, Object actual) {
+        if (expected == actual) {
+            failSame(message);
+        }
+    }
+
+    /**
+     * Asserts that two objects do not refer to the same object. If they do
+     * refer to the same object an AssertionFailedError is thrown.
+     */
+    public static void assertNotSame(Object expected, Object actual) {
+        assertNotSame(null, expected, actual);
+    }
+
+    public static void failSame(String message) {
+        String formatted = (message != null) ? message + " " : "";
+        fail(formatted + "expected not same");
+    }
+
+    public static void failNotSame(String message, Object expected, Object actual) {
+        String formatted = (message != null) ? message + " " : "";
+        fail(formatted + "expected same:<" + expected + "> was not:<" + actual + ">");
+    }
+
+    public static void failNotEquals(String message, Object expected, Object actual) {
+        fail(format(message, expected, actual));
+    }
+
+    public static String format(String message, Object expected, Object actual) {
+        String formatted = "";
+        if (message != null && message.length() > 0) {
+            formatted = message + " ";
+        }
+        return formatted + "expected:<" + expected + "> but was:<" + actual + ">";
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/AssertionFailedError.java b/google3/third_party/java_src/junit/main/java/junit/framework/AssertionFailedError.java
new file mode 100644
index 0000000..e11fbec
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/AssertionFailedError.java
@@ -0,0 +1,29 @@
+package junit.framework;
+
+/**
+ * Thrown when an assertion failed.
+ */
+public class AssertionFailedError extends AssertionError {
+
+    private static final long serialVersionUID = 1L;
+    
+    /**
+     * Constructs a new AssertionFailedError without a detail message.
+     */
+    public AssertionFailedError() {
+    }
+
+    /**
+     * Constructs a new AssertionFailedError with the specified detail message.
+     * A null message is replaced by an empty String.
+     * @param message the detail message. The detail message is saved for later 
+     * retrieval by the {@code Throwable.getMessage()} method.
+     */
+    public AssertionFailedError(String message) {
+        super(defaultString(message));
+    }
+
+    private static String defaultString(String message) {
+        return message == null ? "" : message;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/ComparisonCompactor.java b/google3/third_party/java_src/junit/main/java/junit/framework/ComparisonCompactor.java
new file mode 100644
index 0000000..81ddd5b
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/ComparisonCompactor.java
@@ -0,0 +1,78 @@
+package junit.framework;
+
+public class ComparisonCompactor {
+
+    private static final String ELLIPSIS = "...";
+    private static final String DELTA_END = "]";
+    private static final String DELTA_START = "[";
+
+    private int fContextLength;
+    private String fExpected;
+    private String fActual;
+    private int fPrefix;
+    private int fSuffix;
+
+    public ComparisonCompactor(int contextLength, String expected, String actual) {
+        fContextLength = contextLength;
+        fExpected = expected;
+        fActual = actual;
+    }
+
+    @SuppressWarnings("deprecation")
+    public String compact(String message) {
+        if (fExpected == null || fActual == null || areStringsEqual()) {
+            return Assert.format(message, fExpected, fActual);
+        }
+
+        findCommonPrefix();
+        findCommonSuffix();
+        String expected = compactString(fExpected);
+        String actual = compactString(fActual);
+        return Assert.format(message, expected, actual);
+    }
+
+    private String compactString(String source) {
+        String result = DELTA_START + source.substring(fPrefix, source.length() - fSuffix + 1) + DELTA_END;
+        if (fPrefix > 0) {
+            result = computeCommonPrefix() + result;
+        }
+        if (fSuffix > 0) {
+            result = result + computeCommonSuffix();
+        }
+        return result;
+    }
+
+    private void findCommonPrefix() {
+        fPrefix = 0;
+        int end = Math.min(fExpected.length(), fActual.length());
+        for (; fPrefix < end; fPrefix++) {
+            if (fExpected.charAt(fPrefix) != fActual.charAt(fPrefix)) {
+                break;
+            }
+        }
+    }
+
+    private void findCommonSuffix() {
+        int expectedSuffix = fExpected.length() - 1;
+        int actualSuffix = fActual.length() - 1;
+        for (; actualSuffix >= fPrefix && expectedSuffix >= fPrefix; actualSuffix--, expectedSuffix--) {
+            if (fExpected.charAt(expectedSuffix) != fActual.charAt(actualSuffix)) {
+                break;
+            }
+        }
+        fSuffix = fExpected.length() - expectedSuffix;
+    }
+
+    private String computeCommonPrefix() {
+        return (fPrefix > fContextLength ? ELLIPSIS : "") + fExpected.substring(Math.max(0, fPrefix - fContextLength), fPrefix);
+    }
+
+    private String computeCommonSuffix() {
+        int end = Math.min(fExpected.length() - fSuffix + 1 + fContextLength, fExpected.length());
+        return fExpected.substring(fExpected.length() - fSuffix + 1, end) + (fExpected.length() - fSuffix + 1 < fExpected.length() - fContextLength ? ELLIPSIS : "");
+    }
+
+    private boolean areStringsEqual() {
+        return fExpected.equals(fActual);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/ComparisonFailure.java b/google3/third_party/java_src/junit/main/java/junit/framework/ComparisonFailure.java
new file mode 100644
index 0000000..66433ef
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/ComparisonFailure.java
@@ -0,0 +1,56 @@
+package junit.framework;
+
+/**
+ * Thrown when an assert equals for Strings failed.
+ *
+ * Inspired by a patch from Alex Chaffee mailto:alex@purpletech.com
+ */
+public class ComparisonFailure extends AssertionFailedError {
+    private static final int MAX_CONTEXT_LENGTH = 20;
+    private static final long serialVersionUID = 1L;
+
+    private String fExpected;
+    private String fActual;
+
+    /**
+     * Constructs a comparison failure.
+     *
+     * @param message the identifying message or null
+     * @param expected the expected string value
+     * @param actual the actual string value
+     */
+    public ComparisonFailure(String message, String expected, String actual) {
+        super(message);
+        fExpected = expected;
+        fActual = actual;
+    }
+
+    /**
+     * Returns "..." in place of common prefix and "..." in
+     * place of common suffix between expected and actual.
+     *
+     * @see Throwable#getMessage()
+     */
+    @Override
+    public String getMessage() {
+        return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage());
+    }
+
+    /**
+     * Gets the actual string value
+     *
+     * @return the actual string value
+     */
+    public String getActual() {
+        return fActual;
+    }
+
+    /**
+     * Gets the expected string value
+     *
+     * @return the expected string value
+     */
+    public String getExpected() {
+        return fExpected;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/JUnit4TestAdapter.java b/google3/third_party/java_src/junit/main/java/junit/framework/JUnit4TestAdapter.java
new file mode 100644
index 0000000..9d32031
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/JUnit4TestAdapter.java
@@ -0,0 +1,107 @@
+package junit.framework;
+
+import java.util.List;
+
+import org.junit.Ignore;
+import org.junit.runner.Describable;
+import org.junit.runner.Description;
+import org.junit.runner.Request;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.Filterable;
+import org.junit.runner.manipulation.Orderer;
+import org.junit.runner.manipulation.InvalidOrderingException;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runner.manipulation.Orderable;
+import org.junit.runner.manipulation.Sorter;
+
+/**
+ * The JUnit4TestAdapter enables running JUnit-4-style tests using a JUnit-3-style test runner.
+ *
+ * <p> To use it, add the following to a test class:
+ * <pre>
+      public static Test suite() {
+        return new JUnit4TestAdapter(<em>YourJUnit4TestClass</em>.class);
+      }
+</pre>
+ */
+public class JUnit4TestAdapter implements Test, Filterable, Orderable, Describable {
+    private final Class<?> fNewTestClass;
+
+    private final Runner fRunner;
+
+    private final JUnit4TestAdapterCache fCache;
+
+    public JUnit4TestAdapter(Class<?> newTestClass) {
+        this(newTestClass, JUnit4TestAdapterCache.getDefault());
+    }
+
+    public JUnit4TestAdapter(final Class<?> newTestClass, JUnit4TestAdapterCache cache) {
+        fCache = cache;
+        fNewTestClass = newTestClass;
+        fRunner = Request.classWithoutSuiteMethod(newTestClass).getRunner();
+    }
+
+    public int countTestCases() {
+        return fRunner.testCount();
+    }
+
+    public void run(TestResult result) {
+        fRunner.run(fCache.getNotifier(result, this));
+    }
+
+    // reflective interface for Eclipse
+    public List<Test> getTests() {
+        return fCache.asTestList(getDescription());
+    }
+
+    // reflective interface for Eclipse
+    public Class<?> getTestClass() {
+        return fNewTestClass;
+    }
+
+    public Description getDescription() {
+        Description description = fRunner.getDescription();
+        return removeIgnored(description);
+    }
+
+    private Description removeIgnored(Description description) {
+        if (isIgnored(description)) {
+            return Description.EMPTY;
+        }
+        Description result = description.childlessCopy();
+        for (Description each : description.getChildren()) {
+            Description child = removeIgnored(each);
+            if (!child.isEmpty()) {
+                result.addChild(child);
+            }
+        }
+        return result;
+    }
+
+    private boolean isIgnored(Description description) {
+        return description.getAnnotation(Ignore.class) != null;
+    }
+
+    @Override
+    public String toString() {
+        return fNewTestClass.getName();
+    }
+
+    public void filter(Filter filter) throws NoTestsRemainException {
+        filter.apply(fRunner);
+    }
+
+    public void sort(Sorter sorter) {
+        sorter.apply(fRunner);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @since 4.13
+     */
+    public void order(Orderer orderer) throws InvalidOrderingException {
+        orderer.apply(fRunner);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/JUnit4TestAdapterCache.java b/google3/third_party/java_src/junit/main/java/junit/framework/JUnit4TestAdapterCache.java
new file mode 100644
index 0000000..603f261
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/JUnit4TestAdapterCache.java
@@ -0,0 +1,77 @@
+package junit.framework;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+import org.junit.runner.Description;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+import org.junit.runner.notification.RunNotifier;
+
+public class JUnit4TestAdapterCache extends HashMap<Description, Test> {
+    private static final long serialVersionUID = 1L;
+    private static final JUnit4TestAdapterCache fInstance = new JUnit4TestAdapterCache();
+
+    public static JUnit4TestAdapterCache getDefault() {
+        return fInstance;
+    }
+
+    public Test asTest(Description description) {
+        if (description.isSuite()) {
+            return createTest(description);
+        } else {
+            if (!containsKey(description)) {
+                put(description, createTest(description));
+            }
+            return get(description);
+        }
+    }
+
+    Test createTest(Description description) {
+        if (description.isTest()) {
+            return new JUnit4TestCaseFacade(description);
+        } else {
+            TestSuite suite = new TestSuite(description.getDisplayName());
+            for (Description child : description.getChildren()) {
+                suite.addTest(asTest(child));
+            }
+            return suite;
+        }
+    }
+
+    public RunNotifier getNotifier(final TestResult result, final JUnit4TestAdapter adapter) {
+        RunNotifier notifier = new RunNotifier();
+        notifier.addListener(new RunListener() {
+            @Override
+            public void testFailure(Failure failure) throws Exception {
+                result.addError(asTest(failure.getDescription()), failure.getException());
+            }
+
+            @Override
+            public void testFinished(Description description) throws Exception {
+                result.endTest(asTest(description));
+            }
+
+            @Override
+            public void testStarted(Description description) throws Exception {
+                result.startTest(asTest(description));
+            }
+        });
+        return notifier;
+    }
+
+    public List<Test> asTestList(Description description) {
+        if (description.isTest()) {
+            return Arrays.asList(asTest(description));
+        } else {
+            List<Test> returnThis = new ArrayList<Test>();
+            for (Description child : description.getChildren()) {
+                returnThis.add(asTest(child));
+            }
+            return returnThis;
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/JUnit4TestCaseFacade.java b/google3/third_party/java_src/junit/main/java/junit/framework/JUnit4TestCaseFacade.java
new file mode 100644
index 0000000..5fd8ac7
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/JUnit4TestCaseFacade.java
@@ -0,0 +1,30 @@
+package junit.framework;
+
+import org.junit.runner.Describable;
+import org.junit.runner.Description;
+
+public class JUnit4TestCaseFacade implements Test, Describable {
+    private final Description fDescription;
+
+    JUnit4TestCaseFacade(Description description) {
+        fDescription = description;
+    }
+
+    @Override
+    public String toString() {
+        return getDescription().toString();
+    }
+
+    public int countTestCases() {
+        return 1;
+    }
+
+    public void run(TestResult result) {
+        throw new RuntimeException(
+                "This test stub created only for informational purposes.");
+    }
+
+    public Description getDescription() {
+        return fDescription;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/Protectable.java b/google3/third_party/java_src/junit/main/java/junit/framework/Protectable.java
new file mode 100644
index 0000000..c5ceb16
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/Protectable.java
@@ -0,0 +1,14 @@
+package junit.framework;
+
+/**
+ * A <em>Protectable</em> can be run and can throw a Throwable.
+ *
+ * @see TestResult
+ */
+public interface Protectable {
+
+    /**
+     * Run the following method protected.
+     */
+    public abstract void protect() throws Throwable;
+}
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/Test.java b/google3/third_party/java_src/junit/main/java/junit/framework/Test.java
new file mode 100644
index 0000000..db95c6c
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/Test.java
@@ -0,0 +1,18 @@
+package junit.framework;
+
+/**
+ * A <em>Test</em> can be run and collect its results.
+ *
+ * @see TestResult
+ */
+public interface Test {
+    /**
+     * Counts the number of test cases that will be run by this test.
+     */
+    public abstract int countTestCases();
+
+    /**
+     * Runs a test and collects its result in a TestResult instance.
+     */
+    public abstract void run(TestResult result);
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/TestCase.java b/google3/third_party/java_src/junit/main/java/junit/framework/TestCase.java
new file mode 100644
index 0000000..8e4385f
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/TestCase.java
@@ -0,0 +1,524 @@
+package junit.framework;
+
+import com.google.j2objc.annotations.AutoreleasePool;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+/**
+ * A test case defines the fixture to run multiple tests. To define a test case<br/>
+ * <ol>
+ *   <li>implement a subclass of <code>TestCase</code></li>
+ *   <li>define instance variables that store the state of the fixture</li>
+ *   <li>initialize the fixture state by overriding {@link #setUp()}</li>
+ *   <li>clean-up after a test by overriding {@link #tearDown()}.</li>
+ * </ol>
+ * Each test runs in its own fixture so there
+ * can be no side effects among test runs.
+ * Here is an example:
+ * <pre>
+ * public class MathTest extends TestCase {
+ *    protected double fValue1;
+ *    protected double fValue2;
+ *
+ *    protected void setUp() {
+ *       fValue1= 2.0;
+ *       fValue2= 3.0;
+ *    }
+ * }
+ * </pre>
+ *
+ * For each test implement a method which interacts
+ * with the fixture. Verify the expected results with assertions specified
+ * by calling {@link junit.framework.Assert#assertTrue(String, boolean)} with a boolean.
+ * <pre>
+ *    public void testAdd() {
+ *       double result= fValue1 + fValue2;
+ *       assertTrue(result == 5.0);
+ *    }
+ * </pre>
+ *
+ * Once the methods are defined you can run them. The framework supports
+ * both a static type safe and more dynamic way to run a test.
+ * In the static way you override the runTest method and define the method to
+ * be invoked. A convenient way to do so is with an anonymous inner class.
+ * <pre>
+ * TestCase test= new MathTest("add") {
+ *    public void runTest() {
+ *       testAdd();
+ *    }
+ * };
+ * test.run();
+ * </pre>
+ * The dynamic way uses reflection to implement {@link #runTest()}. It dynamically finds
+ * and invokes a method.
+ * In this case the name of the test case has to correspond to the test method
+ * to be run.
+ * <pre>
+ * TestCase test= new MathTest("testAdd");
+ * test.run();
+ * </pre>
+ *
+ * The tests to be run can be collected into a TestSuite. JUnit provides
+ * different <i>test runners</i> which can run a test suite and collect the results.
+ * A test runner either expects a static method <code>suite</code> as the entry
+ * point to get a test to run or it will extract the suite automatically.
+ * <pre>
+ * public static Test suite() {
+ *    suite.addTest(new MathTest("testAdd"));
+ *    suite.addTest(new MathTest("testDivideByZero"));
+ *    return suite;
+ * }
+ * </pre>
+ *
+ * @see TestResult
+ * @see TestSuite
+ */
+@SuppressWarnings("deprecation")
+public abstract class TestCase extends Assert implements Test {
+    /**
+     * the name of the test case
+     */
+    private String fName;
+
+    /**
+     * No-arg constructor to enable serialization. This method
+     * is not intended to be used by mere mortals without calling setName().
+     */
+    public TestCase() {
+        fName = null;
+    }
+
+    /**
+     * Constructs a test case with the given name.
+     */
+    public TestCase(String name) {
+        fName = name;
+    }
+
+    /**
+     * Counts the number of test cases executed by run(TestResult result).
+     */
+    public int countTestCases() {
+        return 1;
+    }
+
+    /**
+     * Creates a default TestResult object.
+     *
+     * @see TestResult
+     */
+    protected TestResult createResult() {
+        return new TestResult();
+    }
+
+    /**
+     * A convenience method to run this test, collecting the results with a
+     * default TestResult object.
+     *
+     * @see TestResult
+     */
+    public TestResult run() {
+        TestResult result = createResult();
+        run(result);
+        return result;
+    }
+
+    /**
+     * Runs the test case and collects the results in TestResult.
+     */
+    public void run(TestResult result) {
+        result.run(this);
+    }
+
+    /**
+     * Runs the bare test sequence.
+     *
+     * @throws Throwable if any exception is thrown
+     */
+    public void runBare() throws Throwable {
+        Throwable exception = null;
+        setUp();
+        try {
+            runTest();
+        } catch (Throwable running) {
+            exception = running;
+        } finally {
+            try {
+                tearDown();
+            } catch (Throwable tearingDown) {
+                if (exception == null) exception = tearingDown;
+            }
+        }
+        if (exception != null) throw exception;
+    }
+
+    /**
+     * Override to run the test and assert its state.
+     *
+     * @throws Throwable if any exception is thrown
+     */
+    protected void runTest() throws Throwable {
+        assertNotNull("TestCase.fName cannot be null", fName); // Some VMs crash when calling getMethod(null,null);
+        Method runMethod = null;
+        try {
+            // use getMethod to get all public inherited
+            // methods. getDeclaredMethods returns all
+            // methods of this class but excludes the
+            // inherited ones.
+            runMethod = getClass().getMethod(fName, (Class[]) null);
+        } catch (NoSuchMethodException e) {
+            fail("Method \"" + fName + "\" not found");
+        }
+        if (!Modifier.isPublic(runMethod.getModifiers())) {
+            fail("Method \"" + fName + "\" should be public");
+        }
+
+        try {
+            runTest0(runMethod);
+        } catch (InvocationTargetException e) {
+            e.fillInStackTrace();
+            throw e.getTargetException();
+        } catch (IllegalAccessException e) {
+            e.fillInStackTrace();
+            throw e;
+        }
+    }
+
+    /**
+     * Invocation of the test method is pulled into this helper function so that
+     * AutoreleasePool can be applied to the invocation.
+     * This is a local modification to support translation of this code to
+     * Objective-C using J2ObjC. It causes the translator to add an autorelease
+     * pool around this method which is Objective-C's way of collecting and
+     * cleaning up garbage memory.
+     */
+    @AutoreleasePool
+    private void runTest0(Method m) throws InvocationTargetException, IllegalAccessException {
+        m.invoke(this);
+    }
+
+    /**
+     * Asserts that a condition is true. If it isn't it throws
+     * an AssertionFailedError with the given message.
+     */
+    public static void assertTrue(String message, boolean condition) {
+        Assert.assertTrue(message, condition);
+    }
+
+    /**
+     * Asserts that a condition is true. If it isn't it throws
+     * an AssertionFailedError.
+     */
+    public static void assertTrue(boolean condition) {
+        Assert.assertTrue(condition);
+    }
+
+    /**
+     * Asserts that a condition is false. If it isn't it throws
+     * an AssertionFailedError with the given message.
+     */
+    public static void assertFalse(String message, boolean condition) {
+        Assert.assertFalse(message, condition);
+    }
+
+    /**
+     * Asserts that a condition is false. If it isn't it throws
+     * an AssertionFailedError.
+     */
+    public static void assertFalse(boolean condition) {
+        Assert.assertFalse(condition);
+    }
+
+    /**
+     * Fails a test with the given message.
+     */
+    public static void fail(String message) {
+        Assert.fail(message);
+    }
+
+    /**
+     * Fails a test with no message.
+     */
+    public static void fail() {
+        Assert.fail();
+    }
+
+    /**
+     * Asserts that two objects are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, Object expected, Object actual) {
+        Assert.assertEquals(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two objects are equal. If they are not
+     * an AssertionFailedError is thrown.
+     */
+    public static void assertEquals(Object expected, Object actual) {
+        Assert.assertEquals(expected, actual);
+    }
+
+    /**
+     * Asserts that two Strings are equal.
+     */
+    public static void assertEquals(String message, String expected, String actual) {
+        Assert.assertEquals(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two Strings are equal.
+     */
+    public static void assertEquals(String expected, String actual) {
+        Assert.assertEquals(expected, actual);
+    }
+
+    /**
+     * Asserts that two doubles are equal concerning a delta.  If they are not
+     * an AssertionFailedError is thrown with the given message.  If the expected
+     * value is infinity then the delta value is ignored.
+     */
+    public static void assertEquals(String message, double expected, double actual, double delta) {
+        Assert.assertEquals(message, expected, actual, delta);
+    }
+
+    /**
+     * Asserts that two doubles are equal concerning a delta. If the expected
+     * value is infinity then the delta value is ignored.
+     */
+    public static void assertEquals(double expected, double actual, double delta) {
+        Assert.assertEquals(expected, actual, delta);
+    }
+
+    /**
+     * Asserts that two floats are equal concerning a positive delta. If they
+     * are not an AssertionFailedError is thrown with the given message. If the
+     * expected value is infinity then the delta value is ignored.
+     */
+    public static void assertEquals(String message, float expected, float actual, float delta) {
+        Assert.assertEquals(message, expected, actual, delta);
+    }
+
+    /**
+     * Asserts that two floats are equal concerning a delta. If the expected
+     * value is infinity then the delta value is ignored.
+     */
+    public static void assertEquals(float expected, float actual, float delta) {
+        Assert.assertEquals(expected, actual, delta);
+    }
+
+    /**
+     * Asserts that two longs are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, long expected, long actual) {
+        Assert.assertEquals(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two longs are equal.
+     */
+    public static void assertEquals(long expected, long actual) {
+        Assert.assertEquals(expected, actual);
+    }
+
+    /**
+     * Asserts that two booleans are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, boolean expected, boolean actual) {
+        Assert.assertEquals(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two booleans are equal.
+     */
+    public static void assertEquals(boolean expected, boolean actual) {
+        Assert.assertEquals(expected, actual);
+    }
+
+    /**
+     * Asserts that two bytes are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, byte expected, byte actual) {
+        Assert.assertEquals(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two bytes are equal.
+     */
+    public static void assertEquals(byte expected, byte actual) {
+        Assert.assertEquals(expected, actual);
+    }
+
+    /**
+     * Asserts that two chars are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, char expected, char actual) {
+        Assert.assertEquals(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two chars are equal.
+     */
+    public static void assertEquals(char expected, char actual) {
+        Assert.assertEquals(expected, actual);
+    }
+
+    /**
+     * Asserts that two shorts are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, short expected, short actual) {
+        Assert.assertEquals(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two shorts are equal.
+     */
+    public static void assertEquals(short expected, short actual) {
+        Assert.assertEquals(expected, actual);
+    }
+
+    /**
+     * Asserts that two ints are equal. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertEquals(String message, int expected, int actual) {
+        Assert.assertEquals(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two ints are equal.
+     */
+    public static void assertEquals(int expected, int actual) {
+        Assert.assertEquals(expected, actual);
+    }
+
+    /**
+     * Asserts that an object isn't null.
+     */
+    public static void assertNotNull(Object object) {
+        Assert.assertNotNull(object);
+    }
+
+    /**
+     * Asserts that an object isn't null. If it is
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertNotNull(String message, Object object) {
+        Assert.assertNotNull(message, object);
+    }
+
+    /**
+     * Asserts that an object is null. If it isn't an {@link AssertionError} is
+     * thrown.
+     * Message contains: Expected: <null> but was: object
+     *
+     * @param object Object to check or <code>null</code>
+     */
+    public static void assertNull(Object object) {
+        Assert.assertNull(object);
+    }
+
+    /**
+     * Asserts that an object is null.  If it is not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertNull(String message, Object object) {
+        Assert.assertNull(message, object);
+    }
+
+    /**
+     * Asserts that two objects refer to the same object. If they are not
+     * an AssertionFailedError is thrown with the given message.
+     */
+    public static void assertSame(String message, Object expected, Object actual) {
+        Assert.assertSame(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two objects refer to the same object. If they are not
+     * the same an AssertionFailedError is thrown.
+     */
+    public static void assertSame(Object expected, Object actual) {
+        Assert.assertSame(expected, actual);
+    }
+
+    /**
+     * Asserts that two objects do not refer to the same object. If they do
+     * refer to the same object an AssertionFailedError is thrown with the
+     * given message.
+     */
+    public static void assertNotSame(String message, Object expected, Object actual) {
+        Assert.assertNotSame(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two objects do not refer to the same object. If they do
+     * refer to the same object an AssertionFailedError is thrown.
+     */
+    public static void assertNotSame(Object expected, Object actual) {
+        Assert.assertNotSame(expected, actual);
+    }
+
+    public static void failSame(String message) {
+        Assert.failSame(message);
+    }
+
+    public static void failNotSame(String message, Object expected, Object actual) {
+        Assert.failNotSame(message, expected, actual);
+    }
+
+    public static void failNotEquals(String message, Object expected, Object actual) {
+        Assert.failNotEquals(message, expected, actual);
+    }
+
+    public static String format(String message, Object expected, Object actual) {
+        return Assert.format(message, expected, actual);
+    }
+
+    /**
+     * Sets up the fixture, for example, open a network connection.
+     * This method is called before a test is executed.
+     */
+    protected void setUp() throws Exception {
+    }
+
+    /**
+     * Tears down the fixture, for example, close a network connection.
+     * This method is called after a test is executed.
+     */
+    protected void tearDown() throws Exception {
+    }
+
+    /**
+     * Returns a string representation of the test case.
+     */
+    @Override
+    public String toString() {
+        return getName() + "(" + getClass().getName() + ")";
+    }
+
+    /**
+     * Gets the name of a TestCase.
+     *
+     * @return the name of the TestCase
+     */
+    public String getName() {
+        return fName;
+    }
+
+    /**
+     * Sets the name of a TestCase.
+     *
+     * @param name the name to set
+     */
+    public void setName(String name) {
+        fName = name;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/TestFailure.java b/google3/third_party/java_src/junit/main/java/junit/framework/TestFailure.java
new file mode 100644
index 0000000..d1ddfbc
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/TestFailure.java
@@ -0,0 +1,69 @@
+package junit.framework;
+
+import org.junit.internal.Throwables;
+
+
+/**
+ * A {@code TestFailure} collects a failed test together with
+ * the caught exception.
+ *
+ * @see TestResult
+ */
+public class TestFailure {
+    protected Test fFailedTest;
+    protected Throwable fThrownException;
+
+    /**
+     * Constructs a TestFailure with the given test and exception.
+     */
+    public TestFailure(Test failedTest, Throwable thrownException) {
+        fFailedTest = failedTest;
+        fThrownException = thrownException;
+    }
+
+    /**
+     * Gets the failed test.
+     */
+    public Test failedTest() {
+        return fFailedTest;
+    }
+
+    /**
+     * Gets the thrown exception.
+     */
+    public Throwable thrownException() {
+        return fThrownException;
+    }
+
+    /**
+     * Returns a short description of the failure.
+     */
+    @Override
+    public String toString() {
+        return fFailedTest + ": " + fThrownException.getMessage();
+    }
+    
+    /**
+     * Returns a String containing the stack trace of the error
+     * thrown by TestFailure.
+     */
+    public String trace() {
+        return Throwables.getStacktrace(thrownException());
+    }
+
+    /**
+     * Returns a String containing the message from the thrown exception.
+     */
+    public String exceptionMessage() {
+        return thrownException().getMessage();
+    }
+
+    /**
+     * Returns {@code true} if the error is considered a failure
+     * (i.e. if it is an instance of {@code AssertionFailedError}),
+     * {@code false} otherwise.
+     */
+    public boolean isFailure() {
+        return thrownException() instanceof AssertionFailedError;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/TestListener.java b/google3/third_party/java_src/junit/main/java/junit/framework/TestListener.java
new file mode 100644
index 0000000..32d1a7f
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/TestListener.java
@@ -0,0 +1,26 @@
+package junit.framework;
+
+/**
+ * A Listener for test progress
+ */
+public interface TestListener {
+    /**
+     * An error occurred.
+     */
+    public void addError(Test test, Throwable e);
+
+    /**
+     * A failure occurred.
+     */
+    public void addFailure(Test test, AssertionFailedError e);
+
+    /**
+     * A test ended.
+     */
+    public void endTest(Test test);
+
+    /**
+     * A test started.
+     */
+    public void startTest(Test test);
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/TestResult.java b/google3/third_party/java_src/junit/main/java/junit/framework/TestResult.java
new file mode 100644
index 0000000..e01a2b0
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/TestResult.java
@@ -0,0 +1,185 @@
+package junit.framework;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+
+/**
+ * A <code>TestResult</code> collects the results of executing
+ * a test case. It is an instance of the Collecting Parameter pattern.
+ * The test framework distinguishes between <i>failures</i> and <i>errors</i>.
+ * A failure is anticipated and checked for with assertions. Errors are
+ * unanticipated problems like an {@link ArrayIndexOutOfBoundsException}.
+ *
+ * @see Test
+ */
+public class TestResult {
+    protected List<TestFailure> fFailures;
+    protected List<TestFailure> fErrors;
+    protected List<TestListener> fListeners;
+    protected int fRunTests;
+    private boolean fStop;
+
+    public TestResult() {
+        fFailures = new ArrayList<TestFailure>();
+        fErrors = new ArrayList<TestFailure>();
+        fListeners = new ArrayList<TestListener>();
+        fRunTests = 0;
+        fStop = false;
+    }
+
+    /**
+     * Adds an error to the list of errors. The passed in exception
+     * caused the error.
+     */
+    public synchronized void addError(Test test, Throwable e) {
+        fErrors.add(new TestFailure(test, e));
+        for (TestListener each : cloneListeners()) {
+            each.addError(test, e);
+        }
+    }
+
+    /**
+     * Adds a failure to the list of failures. The passed in exception
+     * caused the failure.
+     */
+    public synchronized void addFailure(Test test, AssertionFailedError e) {
+        fFailures.add(new TestFailure(test, e));
+        for (TestListener each : cloneListeners()) {
+            each.addFailure(test, e);
+        }
+    }
+
+    /**
+     * Registers a TestListener.
+     */
+    public synchronized void addListener(TestListener listener) {
+        fListeners.add(listener);
+    }
+
+    /**
+     * Unregisters a TestListener.
+     */
+    public synchronized void removeListener(TestListener listener) {
+        fListeners.remove(listener);
+    }
+
+    /**
+     * Returns a copy of the listeners.
+     */
+    private synchronized List<TestListener> cloneListeners() {
+        List<TestListener> result = new ArrayList<TestListener>();
+        result.addAll(fListeners);
+        return result;
+    }
+
+    /**
+     * Informs the result that a test was completed.
+     */
+    public void endTest(Test test) {
+        for (TestListener each : cloneListeners()) {
+            each.endTest(test);
+        }
+    }
+
+    /**
+     * Gets the number of detected errors.
+     */
+    public synchronized int errorCount() {
+        return fErrors.size();
+    }
+
+    /**
+     * Returns an Enumeration for the errors.
+     */
+    public synchronized Enumeration<TestFailure> errors() {
+        return Collections.enumeration(fErrors);
+    }
+
+
+    /**
+     * Gets the number of detected failures.
+     */
+    public synchronized int failureCount() {
+        return fFailures.size();
+    }
+
+    /**
+     * Returns an Enumeration for the failures.
+     */
+    public synchronized Enumeration<TestFailure> failures() {
+        return Collections.enumeration(fFailures);
+    }
+
+    /**
+     * Runs a TestCase.
+     */
+    protected void run(final TestCase test) {
+        startTest(test);
+        Protectable p = new Protectable() {
+            public void protect() throws Throwable {
+                test.runBare();
+            }
+        };
+        runProtected(test, p);
+
+        endTest(test);
+    }
+
+    /**
+     * Gets the number of run tests.
+     */
+    public synchronized int runCount() {
+        return fRunTests;
+    }
+
+    /**
+     * Runs a TestCase.
+     */
+    public void runProtected(final Test test, Protectable p) {
+        try {
+            p.protect();
+        } catch (AssertionFailedError e) {
+            addFailure(test, e);
+        } catch (ThreadDeath e) { // don't catch ThreadDeath by accident
+            throw e;
+        } catch (Throwable e) {
+            addError(test, e);
+        }
+    }
+
+    /**
+     * Checks whether the test run should stop.
+     */
+    public synchronized boolean shouldStop() {
+        return fStop;
+    }
+
+    /**
+     * Informs the result that a test will be started.
+     */
+    public void startTest(Test test) {
+        final int count = test.countTestCases();
+        synchronized (this) {
+            fRunTests += count;
+        }
+        for (TestListener each : cloneListeners()) {
+            each.startTest(test);
+        }
+    }
+
+    /**
+     * Marks that the test run should stop.
+     */
+    public synchronized void stop() {
+        fStop = true;
+    }
+
+    /**
+     * Returns whether the entire test was successful or not.
+     */
+    public synchronized boolean wasSuccessful() {
+        return failureCount() == 0 && errorCount() == 0;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/TestSuite.java b/google3/third_party/java_src/junit/main/java/junit/framework/TestSuite.java
new file mode 100644
index 0000000..50cd5f8
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/TestSuite.java
@@ -0,0 +1,308 @@
+package junit.framework;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Vector;
+
+import org.junit.internal.MethodSorter;
+import org.junit.internal.Throwables;
+
+/**
+ * A <code>TestSuite</code> is a <code>Composite</code> of Tests.
+ * It runs a collection of test cases. Here is an example using
+ * the dynamic test definition.
+ * <pre>
+ * TestSuite suite= new TestSuite();
+ * suite.addTest(new MathTest("testAdd"));
+ * suite.addTest(new MathTest("testDivideByZero"));
+ * </pre>
+ * <p>
+ * Alternatively, a TestSuite can extract the tests to be run automatically.
+ * To do so you pass the class of your TestCase class to the
+ * TestSuite constructor.
+ * <pre>
+ * TestSuite suite= new TestSuite(MathTest.class);
+ * </pre>
+ * <p>
+ * This constructor creates a suite with all the methods
+ * starting with "test" that take no arguments.
+ * <p>
+ * A final option is to do the same for a large array of test classes.
+ * <pre>
+ * Class[] testClasses = { MathTest.class, AnotherTest.class };
+ * TestSuite suite= new TestSuite(testClasses);
+ * </pre>
+ *
+ * @see Test
+ */
+public class TestSuite implements Test {
+
+    /**
+     * ...as the moon sets over the early morning Merlin, Oregon
+     * mountains, our intrepid adventurers type...
+     */
+    static public Test createTest(Class<?> theClass, String name) {
+        Constructor<?> constructor;
+        try {
+            constructor = getTestConstructor(theClass);
+        } catch (NoSuchMethodException e) {
+            return warning("Class " + theClass.getName() + " has no public constructor TestCase(String name) or TestCase()");
+        }
+        Object test;
+        try {
+            if (constructor.getParameterTypes().length == 0) {
+                test = constructor.newInstance(new Object[0]);
+                if (test instanceof TestCase) {
+                    ((TestCase) test).setName(name);
+                }
+            } else {
+                test = constructor.newInstance(new Object[]{name});
+            }
+        } catch (InstantiationException e) {
+            return (warning("Cannot instantiate test case: " + name + " (" + Throwables.getStacktrace(e) + ")"));
+        } catch (InvocationTargetException e) {
+            return (warning("Exception in constructor: " + name + " (" + Throwables.getStacktrace(e.getTargetException()) + ")"));
+        } catch (IllegalAccessException e) {
+            return (warning("Cannot access test case: " + name + " (" + Throwables.getStacktrace(e) + ")"));
+        }
+        return (Test) test;
+    }
+
+    /**
+     * Gets a constructor which takes a single String as
+     * its argument or a no arg constructor.
+     */
+    public static Constructor<?> getTestConstructor(Class<?> theClass) throws NoSuchMethodException {
+        try {
+            return theClass.getConstructor(String.class);
+        } catch (NoSuchMethodException e) {
+            // fall through
+        }
+        return theClass.getConstructor();
+    }
+
+    /**
+     * Returns a test which will fail and log a warning message.
+     */
+    public static Test warning(final String message) {
+        return new TestCase("warning") {
+            @Override
+            protected void runTest() {
+                fail(message);
+            }
+        };
+    }
+
+    private String fName;
+
+    private Vector<Test> fTests = new Vector<Test>(10); // Cannot convert this to List because it is used directly by some test runners
+
+    /**
+     * Constructs an empty TestSuite.
+     */
+    public TestSuite() {
+    }
+
+    /**
+     * Constructs a TestSuite from the given class. Adds all the methods
+     * starting with "test" as test cases to the suite.
+     * Parts of this method were written at 2337 meters in the Hueffihuette,
+     * Kanton Uri
+     */
+    public TestSuite(final Class<?> theClass) {
+        addTestsFromTestCase(theClass);
+    }
+
+    private void addTestsFromTestCase(final Class<?> theClass) {
+        fName = theClass.getName();
+        try {
+            getTestConstructor(theClass); // Avoid generating multiple error messages
+        } catch (NoSuchMethodException e) {
+            addTest(warning("Class " + theClass.getName() + " has no public constructor TestCase(String name) or TestCase()"));
+            return;
+        }
+
+        if (!Modifier.isPublic(theClass.getModifiers())) {
+            addTest(warning("Class " + theClass.getName() + " is not public"));
+            return;
+        }
+
+        Class<?> superClass = theClass;
+        List<String> names = new ArrayList<String>();
+        while (Test.class.isAssignableFrom(superClass)) {
+            for (Method each : MethodSorter.getDeclaredMethods(superClass)) {
+                addTestMethod(each, names, theClass);
+            }
+            superClass = superClass.getSuperclass();
+        }
+        if (fTests.size() == 0) {
+            addTest(warning("No tests found in " + theClass.getName()));
+        }
+    }
+
+    /**
+     * Constructs a TestSuite from the given class with the given name.
+     *
+     * @see TestSuite#TestSuite(Class)
+     */
+    public TestSuite(Class<? extends TestCase> theClass, String name) {
+        this(theClass);
+        setName(name);
+    }
+
+    /**
+     * Constructs an empty TestSuite.
+     */
+    public TestSuite(String name) {
+        setName(name);
+    }
+
+    /**
+     * Constructs a TestSuite from the given array of classes.
+     *
+     * @param classes {@link TestCase}s
+     */
+    public TestSuite(Class<?>... classes) {
+        for (Class<?> each : classes) {
+            addTest(testCaseForClass(each));
+        }
+    }
+
+    private Test testCaseForClass(Class<?> each) {
+        if (TestCase.class.isAssignableFrom(each)) {
+            return new TestSuite(each.asSubclass(TestCase.class));
+        } else {
+            return warning(each.getCanonicalName() + " does not extend TestCase");
+        }
+    }
+
+    /**
+     * Constructs a TestSuite from the given array of classes with the given name.
+     *
+     * @see TestSuite#TestSuite(Class[])
+     */
+    public TestSuite(Class<? extends TestCase>[] classes, String name) {
+        this(classes);
+        setName(name);
+    }
+
+    /**
+     * Adds a test to the suite.
+     */
+    public void addTest(Test test) {
+        fTests.add(test);
+    }
+
+    /**
+     * Adds the tests from the given class to the suite.
+     */
+    public void addTestSuite(Class<? extends TestCase> testClass) {
+        addTest(new TestSuite(testClass));
+    }
+
+    /**
+     * Counts the number of test cases that will be run by this test.
+     */
+    public int countTestCases() {
+        int count = 0;
+        for (Test each : fTests) {
+            count += each.countTestCases();
+        }
+        return count;
+    }
+
+    /**
+     * Returns the name of the suite. Not all
+     * test suites have a name and this method
+     * can return null.
+     */
+    public String getName() {
+        return fName;
+    }
+
+    /**
+     * Runs the tests and collects their result in a TestResult.
+     */
+    public void run(TestResult result) {
+        for (Test each : fTests) {
+            if (result.shouldStop()) {
+                break;
+            }
+            runTest(each, result);
+        }
+    }
+
+    public void runTest(Test test, TestResult result) {
+        test.run(result);
+    }
+
+    /**
+     * Sets the name of the suite.
+     *
+     * @param name the name to set
+     */
+    public void setName(String name) {
+        fName = name;
+    }
+
+    /**
+     * Returns the test at the given index.
+     */
+    public Test testAt(int index) {
+        return fTests.get(index);
+    }
+
+    /**
+     * Returns the number of tests in this suite.
+     */
+    public int testCount() {
+        return fTests.size();
+    }
+
+    /**
+     * Returns the tests as an enumeration.
+     */
+    public Enumeration<Test> tests() {
+        return fTests.elements();
+    }
+
+    /**
+     */
+    @Override
+    public String toString() {
+        if (getName() != null) {
+            return getName();
+        }
+        return super.toString();
+    }
+
+    private void addTestMethod(Method m, List<String> names, Class<?> theClass) {
+        String name = m.getName();
+        if (names.contains(name)) {
+            return;
+        }
+        if (!isPublicTestMethod(m)) {
+            if (isTestMethod(m)) {
+                addTest(warning("Test method isn't public: " + m.getName() + "(" + theClass.getCanonicalName() + ")"));
+            }
+            return;
+        }
+        names.add(name);
+        addTest(createTest(theClass, name));
+    }
+
+    private boolean isPublicTestMethod(Method m) {
+        return isTestMethod(m) && Modifier.isPublic(m.getModifiers());
+    }
+
+    private boolean isTestMethod(Method m) {
+        return m.getParameterTypes().length == 0 &&
+                m.getName().startsWith("test") &&
+                m.getReturnType().equals(Void.TYPE);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/junit/framework/package-info.java b/google3/third_party/java_src/junit/main/java/junit/framework/package-info.java
new file mode 100644
index 0000000..153a1c8
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/framework/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Provides JUnit v3.x core classes.
+ */
+package junit.framework;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/runner/BaseTestRunner.java b/google3/third_party/java_src/junit/main/java/junit/runner/BaseTestRunner.java
new file mode 100644
index 0000000..d63fae7
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/runner/BaseTestRunner.java
@@ -0,0 +1,326 @@
+package junit.runner;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.text.NumberFormat;
+import java.util.Properties;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestListener;
+import junit.framework.TestSuite;
+
+import org.junit.internal.Throwables;
+
+/**
+ * Base class for all test runners.
+ * This class was born live on stage in Sardinia during XP2000.
+ */
+public abstract class BaseTestRunner implements TestListener {
+    public static final String SUITE_METHODNAME = "suite";
+
+    private static Properties fPreferences;
+    static int fgMaxMessageLength = 500;
+    static boolean fgFilterStack = true;
+    boolean fLoading = true;
+
+    /*
+    * Implementation of TestListener
+    */
+    public synchronized void startTest(Test test) {
+        testStarted(test.toString());
+    }
+
+    protected static void setPreferences(Properties preferences) {
+        fPreferences = preferences;
+    }
+
+    protected static Properties getPreferences() {
+        if (fPreferences == null) {
+            fPreferences = new Properties();
+            fPreferences.put("loading", "true");
+            fPreferences.put("filterstack", "true");
+            readPreferences();
+        }
+        return fPreferences;
+    }
+
+    public static void savePreferences() throws IOException {
+        FileOutputStream fos = new FileOutputStream(getPreferencesFile());
+        try {
+            getPreferences().store(fos, "");
+        } finally {
+            fos.close();
+        }
+    }
+
+    public static void setPreference(String key, String value) {
+        getPreferences().put(key, value);
+    }
+
+    public synchronized void endTest(Test test) {
+        testEnded(test.toString());
+    }
+
+    public synchronized void addError(final Test test, final Throwable e) {
+        testFailed(TestRunListener.STATUS_ERROR, test, e);
+    }
+
+    public synchronized void addFailure(final Test test, final AssertionFailedError e) {
+        testFailed(TestRunListener.STATUS_FAILURE, test, e);
+    }
+
+    // TestRunListener implementation
+
+    public abstract void testStarted(String testName);
+
+    public abstract void testEnded(String testName);
+
+    public abstract void testFailed(int status, Test test, Throwable e);
+
+    /**
+     * Returns the Test corresponding to the given suite. This is
+     * a template method, subclasses override runFailed(), clearStatus().
+     */
+    public Test getTest(String suiteClassName) {
+        if (suiteClassName.length() <= 0) {
+            clearStatus();
+            return null;
+        }
+        Class<?> testClass = null;
+        try {
+            testClass = loadSuiteClass(suiteClassName);
+        } catch (ClassNotFoundException e) {
+            String clazz = e.getMessage();
+            if (clazz == null) {
+                clazz = suiteClassName;
+            }
+            runFailed("Class not found \"" + clazz + "\"");
+            return null;
+        } catch (Exception e) {
+            runFailed("Error: " + e.toString());
+            return null;
+        }
+        Method suiteMethod = null;
+        try {
+            suiteMethod = testClass.getMethod(SUITE_METHODNAME);
+        } catch (Exception e) {
+            // try to extract a test suite automatically
+            clearStatus();
+            return new TestSuite(testClass);
+        }
+        if (!Modifier.isStatic(suiteMethod.getModifiers())) {
+            runFailed("Suite() method must be static");
+            return null;
+        }
+        Test test = null;
+        try {
+            test = (Test) suiteMethod.invoke(null); // static method
+            if (test == null) {
+                return test;
+            }
+        } catch (InvocationTargetException e) {
+            runFailed("Failed to invoke suite():" + e.getTargetException().toString());
+            return null;
+        } catch (IllegalAccessException e) {
+            runFailed("Failed to invoke suite():" + e.toString());
+            return null;
+        }
+
+        clearStatus();
+        return test;
+    }
+
+    /**
+     * Returns the formatted string of the elapsed time.
+     */
+    public String elapsedTimeAsString(long runTime) {
+        return NumberFormat.getInstance().format((double) runTime / 1000);
+    }
+
+    /**
+     * Processes the command line arguments and
+     * returns the name of the suite class to run or null
+     */
+    protected String processArguments(String[] args) {
+        String suiteName = null;
+        for (int i = 0; i < args.length; i++) {
+            if (args[i].equals("-noloading")) {
+                setLoading(false);
+            } else if (args[i].equals("-nofilterstack")) {
+                fgFilterStack = false;
+            } else if (args[i].equals("-c")) {
+                if (args.length > i + 1) {
+                    suiteName = extractClassName(args[i + 1]);
+                } else {
+                    System.out.println("Missing Test class name");
+                }
+                i++;
+            } else {
+                suiteName = args[i];
+            }
+        }
+        return suiteName;
+    }
+
+    /**
+     * Sets the loading behaviour of the test runner
+     */
+    public void setLoading(boolean enable) {
+        fLoading = enable;
+    }
+
+    /**
+     * Extract the class name from a String in VA/Java style
+     */
+    public String extractClassName(String className) {
+        if (className.startsWith("Default package for")) {
+            return className.substring(className.lastIndexOf(".") + 1);
+        }
+        return className;
+    }
+
+    /**
+     * Truncates a String to the maximum length.
+     */
+    public static String truncate(String s) {
+        if (fgMaxMessageLength != -1 && s.length() > fgMaxMessageLength) {
+            s = s.substring(0, fgMaxMessageLength) + "...";
+        }
+        return s;
+    }
+
+    /**
+     * Override to define how to handle a failed loading of
+     * a test suite.
+     */
+    protected abstract void runFailed(String message);
+
+    /**
+     * Returns the loaded Class for a suite name.
+     */
+    protected Class<?> loadSuiteClass(String suiteClassName) throws ClassNotFoundException {
+        return Class.forName(suiteClassName);
+    }
+
+    /**
+     * Clears the status message.
+     */
+    protected void clearStatus() { // Belongs in the GUI TestRunner class
+    }
+
+    protected boolean useReloadingTestSuiteLoader() {
+        return getPreference("loading").equals("true") && fLoading;
+    }
+
+    private static File getPreferencesFile() {
+        String home = System.getProperty("user.home");
+        return new File(home, "junit.properties");
+    }
+
+    private static void readPreferences() {
+        InputStream is = null;
+        try {
+            is = new FileInputStream(getPreferencesFile());
+            setPreferences(new Properties(getPreferences()));
+            getPreferences().load(is);
+        } catch (IOException ignored) {
+        } catch (SecurityException ignored) {
+        } finally {
+            try {
+                if (is != null) {
+                    is.close();
+                }
+            } catch (IOException e1) {
+            }
+        }
+    }
+
+    public static String getPreference(String key) {
+        return getPreferences().getProperty(key);
+    }
+
+    public static int getPreference(String key, int dflt) {
+        String value = getPreference(key);
+        int intValue = dflt;
+        if (value == null) {
+            return intValue;
+        }
+        try {
+            intValue = Integer.parseInt(value);
+        } catch (NumberFormatException ne) {
+        }
+        return intValue;
+    }
+
+    /**
+     * Returns a filtered stack trace
+     */
+    public static String getFilteredTrace(Throwable e) {
+        return BaseTestRunner.getFilteredTrace(Throwables.getStacktrace(e));
+    }
+
+    /**
+     * Filters stack frames from internal JUnit classes
+     */
+    public static String getFilteredTrace(String stack) {
+        if (showStackRaw()) {
+            return stack;
+        }
+
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        StringReader sr = new StringReader(stack);
+        BufferedReader br = new BufferedReader(sr);
+
+        String line;
+        try {
+            while ((line = br.readLine()) != null) {
+                if (!filterLine(line)) {
+                    pw.println(line);
+                }
+            }
+        } catch (Exception IOException) {
+            return stack; // return the stack unfiltered
+        }
+        return sw.toString();
+    }
+
+    protected static boolean showStackRaw() {
+        return !getPreference("filterstack").equals("true") || fgFilterStack == false;
+    }
+
+    static boolean filterLine(String line) {
+        String[] patterns = new String[]{
+                "junit.framework.TestCase",
+                "junit.framework.TestResult",
+                "junit.framework.TestSuite",
+                "junit.framework.Assert.", // don't filter AssertionFailure
+                "junit.swingui.TestRunner",
+                "junit.awtui.TestRunner",
+                "junit.textui.TestRunner",
+                "java.lang.reflect.Method.invoke("
+        };
+        for (int i = 0; i < patterns.length; i++) {
+            if (line.indexOf(patterns[i]) > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static {
+        fgMaxMessageLength = getPreference("maxmessage", fgMaxMessageLength);
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/junit/runner/TestRunListener.java b/google3/third_party/java_src/junit/main/java/junit/runner/TestRunListener.java
new file mode 100644
index 0000000..ce5b3d5
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/runner/TestRunListener.java
@@ -0,0 +1,25 @@
+package junit.runner;
+
+/**
+ * A listener interface for observing the
+ * execution of a test run. Unlike TestListener,
+ * this interface using only primitive objects,
+ * making it suitable for remote test execution.
+ */
+public interface TestRunListener {
+    /* test status constants*/
+    int STATUS_ERROR = 1;
+    int STATUS_FAILURE = 2;
+
+    void testRunStarted(String testSuiteName, int testCount);
+
+    void testRunEnded(long elapsedTime);
+
+    void testRunStopped(long elapsedTime);
+
+    void testStarted(String testName);
+
+    void testEnded(String testName);
+
+    void testFailed(int status, String testName, String trace);
+}
diff --git a/google3/third_party/java_src/junit/main/java/junit/runner/Version.java b/google3/third_party/java_src/junit/main/java/junit/runner/Version.java
new file mode 100644
index 0000000..bb12a70
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/runner/Version.java
@@ -0,0 +1,18 @@
+package junit.runner;
+
+/**
+ * This class defines the current version of JUnit
+ */
+public class Version {
+	private Version() {
+		// don't instantiate
+	}
+
+	public static String id() {
+		return "4.13.2-SNAPSHOT";
+	}
+	
+	public static void main(String[] args) {
+		System.out.println(id());
+	}
+}
diff --git a/google3/third_party/java_src/junit/main/java/junit/runner/Version.java.template b/google3/third_party/java_src/junit/main/java/junit/runner/Version.java.template
new file mode 100644
index 0000000..3182cfd
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/runner/Version.java.template
@@ -0,0 +1,18 @@
+package junit.runner;
+
+/**
+ * This class defines the current version of JUnit
+ */
+public class Version {
+	private Version() {
+		// don't instantiate
+	}
+
+	public static String id() {
+		return "@version@";
+	}
+	
+	public static void main(String[] args) {
+		System.out.println(id());
+	}
+}
diff --git a/google3/third_party/java_src/junit/main/java/junit/runner/package-info.java b/google3/third_party/java_src/junit/main/java/junit/runner/package-info.java
new file mode 100644
index 0000000..b746185
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/runner/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Provides JUnit v3.x test runners.
+ */
+package junit.runner;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/textui/ResultPrinter.java b/google3/third_party/java_src/junit/main/java/junit/textui/ResultPrinter.java
new file mode 100644
index 0000000..95f10f4
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/textui/ResultPrinter.java
@@ -0,0 +1,137 @@
+package junit.textui;
+
+import java.io.PrintStream;
+import java.text.NumberFormat;
+import java.util.Enumeration;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestFailure;
+import junit.framework.TestListener;
+import junit.framework.TestResult;
+import junit.runner.BaseTestRunner;
+
+public class ResultPrinter implements TestListener {
+    PrintStream fWriter;
+    int fColumn = 0;
+
+    public ResultPrinter(PrintStream writer) {
+        fWriter = writer;
+    }
+
+    /* API for use by textui.TestRunner */
+
+    synchronized void print(TestResult result, long runTime) {
+        printHeader(runTime);
+        printErrors(result);
+        printFailures(result);
+        printFooter(result);
+    }
+
+    void printWaitPrompt() {
+        getWriter().println();
+        getWriter().println("<RETURN> to continue");
+    }
+
+    /* Internal methods */
+
+    protected void printHeader(long runTime) {
+        getWriter().println();
+        getWriter().println("Time: " + elapsedTimeAsString(runTime));
+    }
+
+    protected void printErrors(TestResult result) {
+        printDefects(result.errors(), result.errorCount(), "error");
+    }
+
+    protected void printFailures(TestResult result) {
+        printDefects(result.failures(), result.failureCount(), "failure");
+    }
+
+    protected void printDefects(Enumeration<TestFailure> booBoos, int count, String type) {
+        if (count == 0) return;
+        if (count == 1) {
+            getWriter().println("There was " + count + " " + type + ":");
+        } else {
+            getWriter().println("There were " + count + " " + type + "s:");
+        }
+        for (int i = 1; booBoos.hasMoreElements(); i++) {
+            printDefect(booBoos.nextElement(), i);
+        }
+    }
+
+    public void printDefect(TestFailure booBoo, int count) { // only public for testing purposes
+        printDefectHeader(booBoo, count);
+        printDefectTrace(booBoo);
+    }
+
+    protected void printDefectHeader(TestFailure booBoo, int count) {
+        // I feel like making this a println, then adding a line giving the throwable a chance to print something
+        // before we get to the stack trace.
+        getWriter().print(count + ") " + booBoo.failedTest());
+    }
+
+    protected void printDefectTrace(TestFailure booBoo) {
+        getWriter().print(BaseTestRunner.getFilteredTrace(booBoo.trace()));
+    }
+
+    protected void printFooter(TestResult result) {
+        if (result.wasSuccessful()) {
+            getWriter().println();
+            getWriter().print("OK");
+            getWriter().println(" (" + result.runCount() + " test" + (result.runCount() == 1 ? "" : "s") + ")");
+
+        } else {
+            getWriter().println();
+            getWriter().println("FAILURES!!!");
+            getWriter().println("Tests run: " + result.runCount() +
+                    ",  Failures: " + result.failureCount() +
+                    ",  Errors: " + result.errorCount());
+        }
+        getWriter().println();
+    }
+
+    /**
+     * Returns the formatted string of the elapsed time.
+     * Duplicated from BaseTestRunner. Fix it.
+     */
+    protected String elapsedTimeAsString(long runTime) {
+        return NumberFormat.getInstance().format((double) runTime / 1000);
+    }
+
+    public PrintStream getWriter() {
+        return fWriter;
+    }
+
+    /**
+     * @see junit.framework.TestListener#addError(Test, Throwable)
+     */
+    public void addError(Test test, Throwable e) {
+        getWriter().print("E");
+    }
+
+    /**
+     * @see junit.framework.TestListener#addFailure(Test, AssertionFailedError)
+     */
+    public void addFailure(Test test, AssertionFailedError t) {
+        getWriter().print("F");
+    }
+
+    /**
+     * @see junit.framework.TestListener#endTest(Test)
+     */
+    public void endTest(Test test) {
+    }
+
+    /**
+     * @see junit.framework.TestListener#startTest(Test)
+     */
+    public void startTest(Test test) {
+        getWriter().print(".");
+        if (fColumn++ >= 40) {
+            getWriter().println();
+            fColumn = 0;
+        }
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/junit/textui/TestRunner.java b/google3/third_party/java_src/junit/main/java/junit/textui/TestRunner.java
new file mode 100644
index 0000000..913020a
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/textui/TestRunner.java
@@ -0,0 +1,206 @@
+package junit.textui;
+
+
+import java.io.PrintStream;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+import junit.runner.BaseTestRunner;
+import junit.runner.Version;
+
+/**
+ * A command line based tool to run tests.
+ * <pre>
+ * java junit.textui.TestRunner [-wait] TestCaseClass
+ * </pre>
+ * <p>
+ * TestRunner expects the name of a TestCase class as argument.
+ * If this class defines a static <code>suite</code> method it
+ * will be invoked and the returned test is run. Otherwise all
+ * the methods starting with "test" having no arguments are run.
+ * <p>
+ * When the wait command line argument is given TestRunner
+ * waits until the users types RETURN.
+ * <p>
+ * TestRunner prints a trace as the tests are executed followed by a
+ * summary at the end.
+ */
+public class TestRunner extends BaseTestRunner {
+    private ResultPrinter fPrinter;
+
+    public static final int SUCCESS_EXIT = 0;
+    public static final int FAILURE_EXIT = 1;
+    public static final int EXCEPTION_EXIT = 2;
+
+    /**
+     * Constructs a TestRunner.
+     */
+    public TestRunner() {
+        this(System.out);
+    }
+
+    /**
+     * Constructs a TestRunner using the given stream for all the output
+     */
+    public TestRunner(PrintStream writer) {
+        this(new ResultPrinter(writer));
+    }
+
+    /**
+     * Constructs a TestRunner using the given ResultPrinter all the output
+     */
+    public TestRunner(ResultPrinter printer) {
+        fPrinter = printer;
+    }
+
+    /**
+     * Runs a suite extracted from a TestCase subclass.
+     */
+    static public void run(Class<? extends TestCase> testClass) {
+        run(new TestSuite(testClass));
+    }
+
+    /**
+     * Runs a single test and collects its results.
+     * This method can be used to start a test run
+     * from your program.
+     * <pre>
+     * public static void main (String[] args) {
+     *    test.textui.TestRunner.run(suite());
+     * }
+     * </pre>
+     */
+    static public TestResult run(Test test) {
+        TestRunner runner = new TestRunner();
+        return runner.doRun(test);
+    }
+
+    /**
+     * Runs a single test and waits until the user
+     * types RETURN.
+     */
+    static public void runAndWait(Test suite) {
+        TestRunner aTestRunner = new TestRunner();
+        aTestRunner.doRun(suite, true);
+    }
+
+    @Override
+    public void testFailed(int status, Test test, Throwable e) {
+    }
+
+    @Override
+    public void testStarted(String testName) {
+    }
+
+    @Override
+    public void testEnded(String testName) {
+    }
+
+    /**
+     * Creates the TestResult to be used for the test run.
+     */
+    protected TestResult createTestResult() {
+        return new TestResult();
+    }
+
+    public TestResult doRun(Test test) {
+        return doRun(test, false);
+    }
+
+    public TestResult doRun(Test suite, boolean wait) {
+        TestResult result = createTestResult();
+        result.addListener(fPrinter);
+        long startTime = System.currentTimeMillis();
+        suite.run(result);
+        long endTime = System.currentTimeMillis();
+        long runTime = endTime - startTime;
+        fPrinter.print(result, runTime);
+
+        pause(wait);
+        return result;
+    }
+
+    protected void pause(boolean wait) {
+        if (!wait) return;
+        fPrinter.printWaitPrompt();
+        try {
+            System.in.read();
+        } catch (Exception e) {
+        }
+    }
+
+    public static void main(String[] args) {
+        TestRunner aTestRunner = new TestRunner();
+        try {
+            TestResult r = aTestRunner.start(args);
+            if (!r.wasSuccessful()) {
+                System.exit(FAILURE_EXIT);
+            }
+            System.exit(SUCCESS_EXIT);
+        } catch (Exception e) {
+            System.err.println(e.getMessage());
+            System.exit(EXCEPTION_EXIT);
+        }
+    }
+
+    /**
+     * Starts a test run. Analyzes the command line arguments and runs the given
+     * test suite.
+     */
+    public TestResult start(String[] args) throws Exception {
+        String testCase = "";
+        String method = "";
+        boolean wait = false;
+
+        for (int i = 0; i < args.length; i++) {
+            if (args[i].equals("-wait")) {
+                wait = true;
+            } else if (args[i].equals("-c")) {
+                testCase = extractClassName(args[++i]);
+            } else if (args[i].equals("-m")) {
+                String arg = args[++i];
+                int lastIndex = arg.lastIndexOf('.');
+                testCase = arg.substring(0, lastIndex);
+                method = arg.substring(lastIndex + 1);
+            } else if (args[i].equals("-v")) {
+                System.err.println("JUnit " + Version.id() + " by Kent Beck and Erich Gamma");
+            } else {
+                testCase = args[i];
+            }
+        }
+
+        if (testCase.equals("")) {
+            throw new Exception("Usage: TestRunner [-wait] testCaseName, where name is the name of the TestCase class");
+        }
+
+        try {
+            if (!method.equals("")) {
+                return runSingleMethod(testCase, method, wait);
+            }
+            Test suite = getTest(testCase);
+            return doRun(suite, wait);
+        } catch (Exception e) {
+            throw new Exception("Could not create and run test suite: " + e);
+        }
+    }
+
+    protected TestResult runSingleMethod(String testCase, String method, boolean wait) throws Exception {
+        Class<? extends TestCase> testClass = loadSuiteClass(testCase).asSubclass(TestCase.class);
+        Test test = TestSuite.createTest(testClass, method);
+        return doRun(test, wait);
+    }
+
+    @Override
+    protected void runFailed(String message) {
+        System.err.println(message);
+        System.exit(FAILURE_EXIT);
+    }
+
+    public void setPrinter(ResultPrinter printer) {
+        fPrinter = printer;
+    }
+
+
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/junit/textui/package-info.java b/google3/third_party/java_src/junit/main/java/junit/textui/package-info.java
new file mode 100644
index 0000000..2aa5176
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/junit/textui/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Provides JUnit v3.x command line based tool to run tests.
+ */
+package junit.textui;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/After.java b/google3/third_party/java_src/junit/main/java/org/junit/After.java
new file mode 100644
index 0000000..eae7e3a
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/After.java
@@ -0,0 +1,41 @@
+package org.junit;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * If you allocate external resources in a {@link org.junit.Before} method you need to release them
+ * after the test runs. Annotating a <code>public void</code> method
+ * with <code>&#064;After</code> causes that method to be run after the {@link org.junit.Test} method. All <code>&#064;After</code>
+ * methods are guaranteed to run even if a {@link org.junit.Before} or {@link org.junit.Test} method throws an
+ * exception. The <code>&#064;After</code> methods declared in superclasses will be run after those of the current
+ * class, unless they are overridden in the current class.
+ * <p>
+ * Here is a simple example:
+ * <pre>
+ * public class Example {
+ *    File output;
+ *    &#064;Before public void createOutputFile() {
+ *          output= new File(...);
+ *    }
+ *    &#064;Test public void something() {
+ *          ...
+ *    }
+ *    &#064;After public void deleteOutputFile() {
+ *          output.delete();
+ *    }
+ * }
+ * </pre>
+ *
+ * @see org.junit.Before
+ * @see org.junit.Test
+ * @since 4.0
+ */
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface After {
+}
+
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/AfterClass.java b/google3/third_party/java_src/junit/main/java/org/junit/AfterClass.java
new file mode 100644
index 0000000..dba4109
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/AfterClass.java
@@ -0,0 +1,42 @@
+package org.junit;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * If you allocate expensive external resources in a {@link org.junit.BeforeClass} method you need to release them
+ * after all the tests in the class have run. Annotating a <code>public static void</code> method
+ * with <code>&#064;AfterClass</code> causes that method to be run after all the tests in the class have been run. All <code>&#064;AfterClass</code>
+ * methods are guaranteed to run even if a {@link org.junit.BeforeClass} method throws an
+ * exception. The <code>&#064;AfterClass</code> methods declared in superclasses will be run after those of the current
+ * class, unless they are shadowed in the current class.
+ * <p>
+ * Here is a simple example:
+ * <pre>
+ * public class Example {
+ *    private static DatabaseConnection database;
+ *    &#064;BeforeClass public static void login() {
+ *          database= ...;
+ *    }
+ *    &#064;Test public void something() {
+ *          ...
+ *    }
+ *    &#064;Test public void somethingElse() {
+ *          ...
+ *    }
+ *    &#064;AfterClass public static void logout() {
+ *          database.logout();
+ *    }
+ * }
+ * </pre>
+ *
+ * @see org.junit.BeforeClass
+ * @see org.junit.Test
+ * @since 4.0
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface AfterClass {
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/Assert.java b/google3/third_party/java_src/junit/main/java/org/junit/Assert.java
new file mode 100644
index 0000000..65bbc9d
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/Assert.java
@@ -0,0 +1,1034 @@
+package org.junit;
+
+import org.hamcrest.Matcher;
+import org.hamcrest.MatcherAssert;
+import org.junit.function.ThrowingRunnable;
+import org.junit.internal.ArrayComparisonFailure;
+import org.junit.internal.ExactComparisonCriteria;
+import org.junit.internal.InexactComparisonCriteria;
+
+/**
+ * A set of assertion methods useful for writing tests. Only failed assertions
+ * are recorded. These methods can be used directly:
+ * <code>Assert.assertEquals(...)</code>, however, they read better if they
+ * are referenced through static import:
+ *
+ * <pre>
+ * import static org.junit.Assert.*;
+ *    ...
+ *    assertEquals(...);
+ * </pre>
+ *
+ * @see AssertionError
+ * @since 4.0
+ */
+public class Assert {
+    /**
+     * Protect constructor since it is a static only class
+     */
+    protected Assert() {
+    }
+
+    /**
+     * Asserts that a condition is true. If it isn't it throws an
+     * {@link AssertionError} with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param condition condition to be checked
+     */
+    public static void assertTrue(String message, boolean condition) {
+        if (!condition) {
+            fail(message);
+        }
+    }
+
+    /**
+     * Asserts that a condition is true. If it isn't it throws an
+     * {@link AssertionError} without a message.
+     *
+     * @param condition condition to be checked
+     */
+    public static void assertTrue(boolean condition) {
+        assertTrue(null, condition);
+    }
+
+    /**
+     * Asserts that a condition is false. If it isn't it throws an
+     * {@link AssertionError} with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param condition condition to be checked
+     */
+    public static void assertFalse(String message, boolean condition) {
+        assertTrue(message, !condition);
+    }
+
+    /**
+     * Asserts that a condition is false. If it isn't it throws an
+     * {@link AssertionError} without a message.
+     *
+     * @param condition condition to be checked
+     */
+    public static void assertFalse(boolean condition) {
+        assertFalse(null, condition);
+    }
+
+    /**
+     * Fails a test with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @see AssertionError
+     */
+    public static void fail(String message) {
+        if (message == null) {
+            throw new AssertionError();
+        }
+        throw new AssertionError(message);
+    }
+
+    /**
+     * Fails a test with no message.
+     */
+    public static void fail() {
+        fail(null);
+    }
+
+    /**
+     * Asserts that two objects are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message. If
+     * <code>expected</code> and <code>actual</code> are <code>null</code>,
+     * they are considered equal.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expected expected value
+     * @param actual actual value
+     */
+    public static void assertEquals(String message, Object expected,
+            Object actual) {
+        if (equalsRegardingNull(expected, actual)) {
+            return;
+        }
+        if (expected instanceof String && actual instanceof String) {
+            String cleanMessage = message == null ? "" : message;
+            throw new ComparisonFailure(cleanMessage, (String) expected,
+                    (String) actual);
+        } else {
+            failNotEquals(message, expected, actual);
+        }
+    }
+
+    private static boolean equalsRegardingNull(Object expected, Object actual) {
+        if (expected == null) {
+            return actual == null;
+        }
+
+        return isEquals(expected, actual);
+    }
+
+    private static boolean isEquals(Object expected, Object actual) {
+        return expected.equals(actual);
+    }
+
+    /**
+     * Asserts that two objects are equal. If they are not, an
+     * {@link AssertionError} without a message is thrown. If
+     * <code>expected</code> and <code>actual</code> are <code>null</code>,
+     * they are considered equal.
+     *
+     * @param expected expected value
+     * @param actual the value to check against <code>expected</code>
+     */
+    public static void assertEquals(Object expected, Object actual) {
+        assertEquals(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two objects are <b>not</b> equals. If they are, an
+     * {@link AssertionError} is thrown with the given message. If
+     * <code>unexpected</code> and <code>actual</code> are <code>null</code>,
+     * they are considered equal.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param unexpected unexpected value to check
+     * @param actual the value to check against <code>unexpected</code>
+     */
+    public static void assertNotEquals(String message, Object unexpected,
+            Object actual) {
+        if (equalsRegardingNull(unexpected, actual)) {
+            failEquals(message, actual);
+        }
+    }
+
+    /**
+     * Asserts that two objects are <b>not</b> equals. If they are, an
+     * {@link AssertionError} without a message is thrown. If
+     * <code>unexpected</code> and <code>actual</code> are <code>null</code>,
+     * they are considered equal.
+     *
+     * @param unexpected unexpected value to check
+     * @param actual the value to check against <code>unexpected</code>
+     */
+    public static void assertNotEquals(Object unexpected, Object actual) {
+        assertNotEquals(null, unexpected, actual);
+    }
+
+    private static void failEquals(String message, Object actual) {
+        String formatted = "Values should be different. ";
+        if (message != null) {
+            formatted = message + ". ";
+        }
+
+        formatted += "Actual: " + actual;
+        fail(formatted);
+    }
+
+    /**
+     * Asserts that two longs are <b>not</b> equals. If they are, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param unexpected unexpected value to check
+     * @param actual the value to check against <code>unexpected</code>
+     */
+    public static void assertNotEquals(String message, long unexpected, long actual) {
+        if (unexpected == actual) {
+            failEquals(message, Long.valueOf(actual));
+        }
+    }
+
+    /**
+     * Asserts that two longs are <b>not</b> equals. If they are, an
+     * {@link AssertionError} without a message is thrown.
+     *
+     * @param unexpected unexpected value to check
+     * @param actual the value to check against <code>unexpected</code>
+     */
+    public static void assertNotEquals(long unexpected, long actual) {
+        assertNotEquals(null, unexpected, actual);
+    }
+
+    /**
+     * Asserts that two doubles are <b>not</b> equal to within a positive delta.
+     * If they are, an {@link AssertionError} is thrown with the given
+     * message. If the unexpected value is infinity then the delta value is
+     * ignored. NaNs are considered equal:
+     * <code>assertNotEquals(Double.NaN, Double.NaN, *)</code> fails
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param unexpected unexpected value
+     * @param actual the value to check against <code>unexpected</code>
+     * @param delta the maximum delta between <code>unexpected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertNotEquals(String message, double unexpected,
+            double actual, double delta) {
+        if (!doubleIsDifferent(unexpected, actual, delta)) {
+            failEquals(message, Double.valueOf(actual));
+        }
+    }
+
+    /**
+     * Asserts that two doubles are <b>not</b> equal to within a positive delta.
+     * If they are, an {@link AssertionError} is thrown. If the unexpected
+     * value is infinity then the delta value is ignored.NaNs are considered
+     * equal: <code>assertNotEquals(Double.NaN, Double.NaN, *)</code> fails
+     *
+     * @param unexpected unexpected value
+     * @param actual the value to check against <code>unexpected</code>
+     * @param delta the maximum delta between <code>unexpected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertNotEquals(double unexpected, double actual, double delta) {
+        assertNotEquals(null, unexpected, actual, delta);
+    }
+
+    /**
+     * Asserts that two floats are <b>not</b> equal to within a positive delta.
+     * If they are, an {@link AssertionError} is thrown. If the unexpected
+     * value is infinity then the delta value is ignored.NaNs are considered
+     * equal: <code>assertNotEquals(Float.NaN, Float.NaN, *)</code> fails
+     *
+     * @param unexpected unexpected value
+     * @param actual the value to check against <code>unexpected</code>
+     * @param delta the maximum delta between <code>unexpected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertNotEquals(float unexpected, float actual, float delta) {
+        assertNotEquals(null, unexpected, actual, delta);
+    }
+
+    /**
+     * Asserts that two object arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message. If
+     * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
+     * they are considered equal.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expecteds Object array or array of arrays (multi-dimensional array) with
+     * expected values.
+     * @param actuals Object array or array of arrays (multi-dimensional array) with
+     * actual values
+     */
+    public static void assertArrayEquals(String message, Object[] expecteds,
+            Object[] actuals) throws ArrayComparisonFailure {
+        internalArrayEquals(message, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two object arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown. If <code>expected</code> and
+     * <code>actual</code> are <code>null</code>, they are considered
+     * equal.
+     *
+     * @param expecteds Object array or array of arrays (multi-dimensional array) with
+     * expected values
+     * @param actuals Object array or array of arrays (multi-dimensional array) with
+     * actual values
+     */
+    public static void assertArrayEquals(Object[] expecteds, Object[] actuals) {
+        assertArrayEquals(null, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two boolean arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message. If
+     * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
+     * they are considered equal.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expecteds boolean array with expected values.
+     * @param actuals boolean array with expected values.
+     */
+    public static void assertArrayEquals(String message, boolean[] expecteds,
+            boolean[] actuals) throws ArrayComparisonFailure {
+        internalArrayEquals(message, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two boolean arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown. If <code>expected</code> and
+     * <code>actual</code> are <code>null</code>, they are considered
+     * equal.
+     *
+     * @param expecteds boolean array with expected values.
+     * @param actuals boolean array with expected values.
+     */
+    public static void assertArrayEquals(boolean[] expecteds, boolean[] actuals) {
+        assertArrayEquals(null, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two byte arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expecteds byte array with expected values.
+     * @param actuals byte array with actual values
+     */
+    public static void assertArrayEquals(String message, byte[] expecteds,
+            byte[] actuals) throws ArrayComparisonFailure {
+        internalArrayEquals(message, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two byte arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown.
+     *
+     * @param expecteds byte array with expected values.
+     * @param actuals byte array with actual values
+     */
+    public static void assertArrayEquals(byte[] expecteds, byte[] actuals) {
+        assertArrayEquals(null, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two char arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expecteds char array with expected values.
+     * @param actuals char array with actual values
+     */
+    public static void assertArrayEquals(String message, char[] expecteds,
+            char[] actuals) throws ArrayComparisonFailure {
+        internalArrayEquals(message, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two char arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown.
+     *
+     * @param expecteds char array with expected values.
+     * @param actuals char array with actual values
+     */
+    public static void assertArrayEquals(char[] expecteds, char[] actuals) {
+        assertArrayEquals(null, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two short arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expecteds short array with expected values.
+     * @param actuals short array with actual values
+     */
+    public static void assertArrayEquals(String message, short[] expecteds,
+            short[] actuals) throws ArrayComparisonFailure {
+        internalArrayEquals(message, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two short arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown.
+     *
+     * @param expecteds short array with expected values.
+     * @param actuals short array with actual values
+     */
+    public static void assertArrayEquals(short[] expecteds, short[] actuals) {
+        assertArrayEquals(null, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two int arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expecteds int array with expected values.
+     * @param actuals int array with actual values
+     */
+    public static void assertArrayEquals(String message, int[] expecteds,
+            int[] actuals) throws ArrayComparisonFailure {
+        internalArrayEquals(message, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two int arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown.
+     *
+     * @param expecteds int array with expected values.
+     * @param actuals int array with actual values
+     */
+    public static void assertArrayEquals(int[] expecteds, int[] actuals) {
+        assertArrayEquals(null, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two long arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expecteds long array with expected values.
+     * @param actuals long array with actual values
+     */
+    public static void assertArrayEquals(String message, long[] expecteds,
+            long[] actuals) throws ArrayComparisonFailure {
+        internalArrayEquals(message, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two long arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown.
+     *
+     * @param expecteds long array with expected values.
+     * @param actuals long array with actual values
+     */
+    public static void assertArrayEquals(long[] expecteds, long[] actuals) {
+        assertArrayEquals(null, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two double arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expecteds double array with expected values.
+     * @param actuals double array with actual values
+     * @param delta the maximum delta between <code>expecteds[i]</code> and
+     * <code>actuals[i]</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertArrayEquals(String message, double[] expecteds,
+            double[] actuals, double delta) throws ArrayComparisonFailure {
+        new InexactComparisonCriteria(delta).arrayEquals(message, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two double arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown.
+     *
+     * @param expecteds double array with expected values.
+     * @param actuals double array with actual values
+     * @param delta the maximum delta between <code>expecteds[i]</code> and
+     * <code>actuals[i]</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertArrayEquals(double[] expecteds, double[] actuals, double delta) {
+        assertArrayEquals(null, expecteds, actuals, delta);
+    }
+
+    /**
+     * Asserts that two float arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expecteds float array with expected values.
+     * @param actuals float array with actual values
+     * @param delta the maximum delta between <code>expecteds[i]</code> and
+     * <code>actuals[i]</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertArrayEquals(String message, float[] expecteds,
+            float[] actuals, float delta) throws ArrayComparisonFailure {
+        new InexactComparisonCriteria(delta).arrayEquals(message, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two float arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown.
+     *
+     * @param expecteds float array with expected values.
+     * @param actuals float array with actual values
+     * @param delta the maximum delta between <code>expecteds[i]</code> and
+     * <code>actuals[i]</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertArrayEquals(float[] expecteds, float[] actuals, float delta) {
+        assertArrayEquals(null, expecteds, actuals, delta);
+    }
+
+    /**
+     * Asserts that two object arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message. If
+     * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
+     * they are considered equal.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expecteds Object array or array of arrays (multi-dimensional array) with
+     * expected values.
+     * @param actuals Object array or array of arrays (multi-dimensional array) with
+     * actual values
+     */
+    private static void internalArrayEquals(String message, Object expecteds,
+            Object actuals) throws ArrayComparisonFailure {
+        new ExactComparisonCriteria().arrayEquals(message, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two doubles are equal to within a positive delta.
+     * If they are not, an {@link AssertionError} is thrown with the given
+     * message. If the expected value is infinity then the delta value is
+     * ignored. NaNs are considered equal:
+     * <code>assertEquals(Double.NaN, Double.NaN, *)</code> passes
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expected expected value
+     * @param actual the value to check against <code>expected</code>
+     * @param delta the maximum delta between <code>expected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertEquals(String message, double expected,
+            double actual, double delta) {
+        if (doubleIsDifferent(expected, actual, delta)) {
+            failNotEquals(message, Double.valueOf(expected), Double.valueOf(actual));
+        }
+    }
+
+    /**
+     * Asserts that two floats are equal to within a positive delta.
+     * If they are not, an {@link AssertionError} is thrown with the given
+     * message. If the expected value is infinity then the delta value is
+     * ignored. NaNs are considered equal:
+     * <code>assertEquals(Float.NaN, Float.NaN, *)</code> passes
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expected expected value
+     * @param actual the value to check against <code>expected</code>
+     * @param delta the maximum delta between <code>expected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertEquals(String message, float expected,
+            float actual, float delta) {
+        if (floatIsDifferent(expected, actual, delta)) {
+            failNotEquals(message, Float.valueOf(expected), Float.valueOf(actual));
+        }
+    }
+
+    /**
+     * Asserts that two floats are <b>not</b> equal to within a positive delta.
+     * If they are, an {@link AssertionError} is thrown with the given
+     * message. If the unexpected value is infinity then the delta value is
+     * ignored. NaNs are considered equal:
+     * <code>assertNotEquals(Float.NaN, Float.NaN, *)</code> fails
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param unexpected unexpected value
+     * @param actual the value to check against <code>unexpected</code>
+     * @param delta the maximum delta between <code>unexpected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertNotEquals(String message, float unexpected,
+            float actual, float delta) {
+        if (!floatIsDifferent(unexpected, actual, delta)) {
+            failEquals(message, Float.valueOf(actual));
+        }
+    }
+
+    private static boolean doubleIsDifferent(double d1, double d2, double delta) {
+        if (Double.compare(d1, d2) == 0) {
+            return false;
+        }
+        if ((Math.abs(d1 - d2) <= delta)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    private static boolean floatIsDifferent(float f1, float f2, float delta) {
+        if (Float.compare(f1, f2) == 0) {
+            return false;
+        }
+        if ((Math.abs(f1 - f2) <= delta)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Asserts that two longs are equal. If they are not, an
+     * {@link AssertionError} is thrown.
+     *
+     * @param expected expected long value.
+     * @param actual actual long value
+     */
+    public static void assertEquals(long expected, long actual) {
+        assertEquals(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two longs are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expected long expected value.
+     * @param actual long actual value
+     */
+    public static void assertEquals(String message, long expected, long actual) {
+        if (expected != actual) {
+            failNotEquals(message, Long.valueOf(expected), Long.valueOf(actual));
+        }
+    }
+
+    /**
+     * @deprecated Use
+     *             <code>assertEquals(double expected, double actual, double delta)</code>
+     *             instead
+     */
+    @Deprecated
+    public static void assertEquals(double expected, double actual) {
+        assertEquals(null, expected, actual);
+    }
+
+    /**
+     * @deprecated Use
+     *             <code>assertEquals(String message, double expected, double actual, double delta)</code>
+     *             instead
+     */
+    @Deprecated
+    public static void assertEquals(String message, double expected,
+            double actual) {
+        fail("Use assertEquals(expected, actual, delta) to compare floating-point numbers");
+    }
+
+    /**
+     * Asserts that two doubles are equal to within a positive delta.
+     * If they are not, an {@link AssertionError} is thrown. If the expected
+     * value is infinity then the delta value is ignored.NaNs are considered
+     * equal: <code>assertEquals(Double.NaN, Double.NaN, *)</code> passes
+     *
+     * @param expected expected value
+     * @param actual the value to check against <code>expected</code>
+     * @param delta the maximum delta between <code>expected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertEquals(double expected, double actual, double delta) {
+        assertEquals(null, expected, actual, delta);
+    }
+
+    /**
+     * Asserts that two floats are equal to within a positive delta.
+     * If they are not, an {@link AssertionError} is thrown. If the expected
+     * value is infinity then the delta value is ignored. NaNs are considered
+     * equal: <code>assertEquals(Float.NaN, Float.NaN, *)</code> passes
+     *
+     * @param expected expected value
+     * @param actual the value to check against <code>expected</code>
+     * @param delta the maximum delta between <code>expected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    public static void assertEquals(float expected, float actual, float delta) {
+        assertEquals(null, expected, actual, delta);
+    }
+
+    /**
+     * Asserts that an object isn't null. If it is an {@link AssertionError} is
+     * thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param object Object to check or <code>null</code>
+     */
+    public static void assertNotNull(String message, Object object) {
+        assertTrue(message, object != null);
+    }
+
+    /**
+     * Asserts that an object isn't null. If it is an {@link AssertionError} is
+     * thrown.
+     *
+     * @param object Object to check or <code>null</code>
+     */
+    public static void assertNotNull(Object object) {
+        assertNotNull(null, object);
+    }
+
+    /**
+     * Asserts that an object is null. If it is not, an {@link AssertionError}
+     * is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param object Object to check or <code>null</code>
+     */
+    public static void assertNull(String message, Object object) {
+        if (object == null) {
+            return;
+        }
+        failNotNull(message, object);
+    }
+
+    /**
+     * Asserts that an object is null. If it isn't an {@link AssertionError} is
+     * thrown.
+     *
+     * @param object Object to check or <code>null</code>
+     */
+    public static void assertNull(Object object) {
+        assertNull(null, object);
+    }
+
+    private static void failNotNull(String message, Object actual) {
+        String formatted = "";
+        if (message != null) {
+            formatted = message + " ";
+        }
+        fail(formatted + "expected null, but was:<" + actual + ">");
+    }
+
+    /**
+     * Asserts that two objects refer to the same object. If they are not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expected the expected object
+     * @param actual the object to compare to <code>expected</code>
+     */
+    public static void assertSame(String message, Object expected, Object actual) {
+        if (expected == actual) {
+            return;
+        }
+        failNotSame(message, expected, actual);
+    }
+
+    /**
+     * Asserts that two objects refer to the same object. If they are not the
+     * same, an {@link AssertionError} without a message is thrown.
+     *
+     * @param expected the expected object
+     * @param actual the object to compare to <code>expected</code>
+     */
+    public static void assertSame(Object expected, Object actual) {
+        assertSame(null, expected, actual);
+    }
+
+    /**
+     * Asserts that two objects do not refer to the same object. If they do
+     * refer to the same object, an {@link AssertionError} is thrown with the
+     * given message.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param unexpected the object you don't expect
+     * @param actual the object to compare to <code>unexpected</code>
+     */
+    public static void assertNotSame(String message, Object unexpected,
+            Object actual) {
+        if (unexpected == actual) {
+            failSame(message);
+        }
+    }
+
+    /**
+     * Asserts that two objects do not refer to the same object. If they do
+     * refer to the same object, an {@link AssertionError} without a message is
+     * thrown.
+     *
+     * @param unexpected the object you don't expect
+     * @param actual the object to compare to <code>unexpected</code>
+     */
+    public static void assertNotSame(Object unexpected, Object actual) {
+        assertNotSame(null, unexpected, actual);
+    }
+
+    private static void failSame(String message) {
+        String formatted = "";
+        if (message != null) {
+            formatted = message + " ";
+        }
+        fail(formatted + "expected not same");
+    }
+
+    private static void failNotSame(String message, Object expected,
+            Object actual) {
+        String formatted = "";
+        if (message != null) {
+            formatted = message + " ";
+        }
+        fail(formatted + "expected same:<" + expected + "> was not:<" + actual
+                + ">");
+    }
+
+    private static void failNotEquals(String message, Object expected,
+            Object actual) {
+        fail(format(message, expected, actual));
+    }
+
+    static String format(String message, Object expected, Object actual) {
+        String formatted = "";
+        if (message != null && !"".equals(message)) {
+            formatted = message + " ";
+        }
+        String expectedString = String.valueOf(expected);
+        String actualString = String.valueOf(actual);
+        if (equalsRegardingNull(expectedString, actualString)) {
+            return formatted + "expected: "
+                    + formatClassAndValue(expected, expectedString)
+                    + " but was: " + formatClassAndValue(actual, actualString);
+        } else {
+            return formatted + "expected:<" + expectedString + "> but was:<"
+                    + actualString + ">";
+        }
+    }
+
+    private static String formatClass(Class<?> value) {
+        String className = value.getCanonicalName();
+        return className == null ? value.getName() : className;
+    }
+
+    private static String formatClassAndValue(Object value, String valueString) {
+        String className = value == null ? "null" : value.getClass().getName();
+        return className + "<" + valueString + ">";
+    }
+
+    /**
+     * Asserts that two object arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown with the given message. If
+     * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
+     * they are considered equal.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expecteds Object array or array of arrays (multi-dimensional array) with
+     * expected values.
+     * @param actuals Object array or array of arrays (multi-dimensional array) with
+     * actual values
+     * @deprecated use assertArrayEquals
+     */
+    @Deprecated
+    public static void assertEquals(String message, Object[] expecteds,
+            Object[] actuals) {
+        assertArrayEquals(message, expecteds, actuals);
+    }
+
+    /**
+     * Asserts that two object arrays are equal. If they are not, an
+     * {@link AssertionError} is thrown. If <code>expected</code> and
+     * <code>actual</code> are <code>null</code>, they are considered
+     * equal.
+     *
+     * @param expecteds Object array or array of arrays (multi-dimensional array) with
+     * expected values
+     * @param actuals Object array or array of arrays (multi-dimensional array) with
+     * actual values
+     * @deprecated use assertArrayEquals
+     */
+    @Deprecated
+    public static void assertEquals(Object[] expecteds, Object[] actuals) {
+        assertArrayEquals(expecteds, actuals);
+    }
+
+    /**
+     * Asserts that <code>actual</code> satisfies the condition specified by
+     * <code>matcher</code>. If not, an {@link AssertionError} is thrown with
+     * information about the matcher and failing value. Example:
+     *
+     * <pre>
+     *   assertThat(0, is(1)); // fails:
+     *     // failure message:
+     *     // expected: is &lt;1&gt;
+     *     // got value: &lt;0&gt;
+     *   assertThat(0, is(not(1))) // passes
+     * </pre>
+     *
+     * <code>org.hamcrest.Matcher</code> does not currently document the meaning
+     * of its type parameter <code>T</code>.  This method assumes that a matcher
+     * typed as <code>Matcher&lt;T&gt;</code> can be meaningfully applied only
+     * to values that could be assigned to a variable of type <code>T</code>.
+     *
+     * @param <T> the static type accepted by the matcher (this can flag obvious
+     * compile-time problems such as {@code assertThat(1, is("a"))}
+     * @param actual the computed value being compared
+     * @param matcher an expression, built of {@link Matcher}s, specifying allowed
+     * values
+     * @see org.hamcrest.CoreMatchers
+     * @deprecated use {@code org.hamcrest.MatcherAssert.assertThat()}
+     */
+    @Deprecated
+    public static <T> void assertThat(T actual, Matcher<? super T> matcher) {
+        assertThat("", actual, matcher);
+    }
+
+    /**
+     * Asserts that <code>actual</code> satisfies the condition specified by
+     * <code>matcher</code>. If not, an {@link AssertionError} is thrown with
+     * the reason and information about the matcher and failing value. Example:
+     *
+     * <pre>
+     *   assertThat(&quot;Help! Integers don't work&quot;, 0, is(1)); // fails:
+     *     // failure message:
+     *     // Help! Integers don't work
+     *     // expected: is &lt;1&gt;
+     *     // got value: &lt;0&gt;
+     *   assertThat(&quot;Zero is one&quot;, 0, is(not(1))) // passes
+     * </pre>
+     *
+     * <code>org.hamcrest.Matcher</code> does not currently document the meaning
+     * of its type parameter <code>T</code>.  This method assumes that a matcher
+     * typed as <code>Matcher&lt;T&gt;</code> can be meaningfully applied only
+     * to values that could be assigned to a variable of type <code>T</code>.
+     *
+     * @param reason additional information about the error
+     * @param <T> the static type accepted by the matcher (this can flag obvious
+     * compile-time problems such as {@code assertThat(1, is("a"))}
+     * @param actual the computed value being compared
+     * @param matcher an expression, built of {@link Matcher}s, specifying allowed
+     * values
+     * @see org.hamcrest.CoreMatchers
+     * @deprecated use {@code org.hamcrest.MatcherAssert.assertThat()}
+     */
+    @Deprecated
+    public static <T> void assertThat(String reason, T actual,
+            Matcher<? super T> matcher) {
+        MatcherAssert.assertThat(reason, actual, matcher);
+    }
+
+    /**
+     * Asserts that {@code runnable} throws an exception of type {@code expectedThrowable} when
+     * executed. If it does, the exception object is returned. If it does not throw an exception, an
+     * {@link AssertionError} is thrown. If it throws the wrong type of exception, an {@code
+     * AssertionError} is thrown describing the mismatch; the exception that was actually thrown can
+     * be obtained by calling {@link AssertionError#getCause}.
+     *
+     * @param expectedThrowable the expected type of the exception
+     * @param runnable       a function that is expected to throw an exception when executed
+     * @return the exception thrown by {@code runnable}
+     * @since 4.13
+     */
+    public static <T extends Throwable> T assertThrows(Class<T> expectedThrowable,
+            ThrowingRunnable runnable) {
+        return assertThrows(null, expectedThrowable, runnable);
+    }
+
+    /**
+     * Asserts that {@code runnable} throws an exception of type {@code expectedThrowable} when
+     * executed. If it does, the exception object is returned. If it does not throw an exception, an
+     * {@link AssertionError} is thrown. If it throws the wrong type of exception, an {@code
+     * AssertionError} is thrown describing the mismatch; the exception that was actually thrown can
+     * be obtained by calling {@link AssertionError#getCause}.
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expectedThrowable the expected type of the exception
+     * @param runnable a function that is expected to throw an exception when executed
+     * @return the exception thrown by {@code runnable}
+     * @since 4.13
+     */
+    public static <T extends Throwable> T assertThrows(String message, Class<T> expectedThrowable,
+            ThrowingRunnable runnable) {
+        try {
+            runnable.run();
+        } catch (Throwable actualThrown) {
+            if (expectedThrowable.isInstance(actualThrown)) {
+                @SuppressWarnings("unchecked") T retVal = (T) actualThrown;
+                return retVal;
+            } else {
+                String expected = formatClass(expectedThrowable);
+                Class<? extends Throwable> actualThrowable = actualThrown.getClass();
+                String actual = formatClass(actualThrowable);
+                if (expected.equals(actual)) {
+                    // There must be multiple class loaders. Add the identity hash code so the message
+                    // doesn't say "expected: java.lang.String<my.package.MyException> ..."
+                    expected += "@" + Integer.toHexString(System.identityHashCode(expectedThrowable));
+                    actual += "@" + Integer.toHexString(System.identityHashCode(actualThrowable));
+                }
+                String mismatchMessage = buildPrefix(message)
+                        + format("unexpected exception type thrown;", expected, actual);
+
+                // The AssertionError(String, Throwable) ctor is only available on JDK7.
+                AssertionError assertionError = new AssertionError(mismatchMessage);
+                assertionError.initCause(actualThrown);
+                throw assertionError;
+            }
+        }
+        String notThrownMessage = buildPrefix(message) + String
+                .format("expected %s to be thrown, but nothing was thrown",
+                        formatClass(expectedThrowable));
+        throw new AssertionError(notThrownMessage);
+    }
+
+    private static String buildPrefix(String message) {
+        return message != null && message.length() != 0 ? message + ": " : "";
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/Assume.java b/google3/third_party/java_src/junit/main/java/org/junit/Assume.java
new file mode 100644
index 0000000..29b705b
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/Assume.java
@@ -0,0 +1,169 @@
+package org.junit;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.everyItem;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.CoreMatchers.nullValue;
+
+import org.hamcrest.Matcher;
+
+/**
+ * A set of methods useful for stating assumptions about the conditions in which a test is meaningful.
+ * A failed assumption does not mean the code is broken, but that the test provides no useful information. Assume
+ * basically means "don't run this test if these conditions don't apply". The default JUnit runner skips tests with
+ * failing assumptions. Custom runners may behave differently.
+ * <p>
+ *     A good example of using assumptions is in <a href="https://github.com/junit-team/junit4/wiki/Theories">Theories</a> where they are needed to exclude certain datapoints that aren't suitable or allowed for a certain test case.
+ * </p>
+ * Failed assumptions are usually not logged, because there may be many tests that don't apply to certain
+ * configurations.
+ *
+ * <p>
+ * These methods can be used directly: <code>Assume.assumeTrue(...)</code>, however, they
+ * read better if they are referenced through static import:<br/>
+ * <pre>
+ * import static org.junit.Assume.*;
+ *    ...
+ *    assumeTrue(...);
+ * </pre>
+ * </p>
+ *
+ * @see <a href="https://github.com/junit-team/junit4/wiki/Theories">Theories</a>
+ *
+ * @since 4.4
+ */
+public class Assume {
+
+    /**
+     * Do not instantiate.
+     * @deprecated since 4.13.
+     */
+    @Deprecated
+    public Assume() {
+    }
+
+    /**
+     * If called with an expression evaluating to {@code false}, the test will halt and be ignored.
+     */
+    public static void assumeTrue(boolean b) {
+        assumeThat(b, is(true));
+    }
+
+    /**
+     * The inverse of {@link #assumeTrue(boolean)}.
+     */
+    public static void assumeFalse(boolean b) {
+        assumeThat(b, is(false));
+    }
+
+    /**
+     * If called with an expression evaluating to {@code false}, the test will halt and be ignored.
+     *
+     * @param b If <code>false</code>, the method will attempt to stop the test and ignore it by
+     * throwing {@link AssumptionViolatedException}.
+     * @param message A message to pass to {@link AssumptionViolatedException}.
+     */
+    public static void assumeTrue(String message, boolean b) {
+        if (!b) throw new AssumptionViolatedException(message);
+    }
+
+    /**
+     * The inverse of {@link #assumeTrue(String, boolean)}.
+     */
+    public static void assumeFalse(String message, boolean b) {
+        assumeTrue(message, !b);
+    }
+
+    /**
+     * If called with a {@code null} array or one or more {@code null} elements in {@code objects},
+     * the test will halt and be ignored.
+     */
+    public static void assumeNotNull(Object... objects) {
+        assumeThat(objects, notNullValue());
+        assumeThat(asList(objects), everyItem(notNullValue()));
+    }
+
+    /**
+     * Call to assume that <code>actual</code> satisfies the condition specified by <code>matcher</code>.
+     * If not, the test halts and is ignored.
+     * Example:
+     * <pre>:
+     *   assumeThat(1, is(1)); // passes
+     *   foo(); // will execute
+     *   assumeThat(0, is(1)); // assumption failure! test halts
+     *   int x = 1 / 0; // will never execute
+     * </pre>
+     *
+     * @param <T> the static type accepted by the matcher (this can flag obvious compile-time problems such as {@code assumeThat(1, is("a"))}
+     * @param actual the computed value being compared
+     * @param matcher an expression, built of {@link Matcher}s, specifying allowed values
+     * @see org.hamcrest.CoreMatchers
+     * @see org.junit.matchers.JUnitMatchers
+     */
+    public static <T> void assumeThat(T actual, Matcher<T> matcher) {
+        if (!matcher.matches(actual)) {
+            throw new AssumptionViolatedException(actual, matcher);
+        }
+    }
+
+    /**
+     * Call to assume that <code>actual</code> satisfies the condition specified by <code>matcher</code>.
+     * If not, the test halts and is ignored.
+     * Example:
+     * <pre>:
+     *   assumeThat("alwaysPasses", 1, is(1)); // passes
+     *   foo(); // will execute
+     *   assumeThat("alwaysFails", 0, is(1)); // assumption failure! test halts
+     *   int x = 1 / 0; // will never execute
+     * </pre>
+     *
+     * @param <T> the static type accepted by the matcher (this can flag obvious compile-time problems such as {@code assumeThat(1, is("a"))}
+     * @param actual the computed value being compared
+     * @param matcher an expression, built of {@link Matcher}s, specifying allowed values
+     * @see org.hamcrest.CoreMatchers
+     * @see org.junit.matchers.JUnitMatchers
+     */
+    public static <T> void assumeThat(String message, T actual, Matcher<T> matcher) {
+        if (!matcher.matches(actual)) {
+            throw new AssumptionViolatedException(message, actual, matcher);
+        }
+    }
+
+    /**
+     * Use to assume that an operation completes normally.  If {@code e} is non-null, the test will halt and be ignored.
+     *
+     * For example:
+     * <pre>
+     * \@Test public void parseDataFile() {
+     *   DataFile file;
+     *   try {
+     *     file = DataFile.open("sampledata.txt");
+     *   } catch (IOException e) {
+     *     // stop test and ignore if data can't be opened
+     *     assumeNoException(e);
+     *   }
+     *   // ...
+     * }
+     * </pre>
+     *
+     * @param e if non-null, the offending exception
+     */
+    public static void assumeNoException(Throwable e) {
+        assumeThat(e, nullValue());
+    }
+
+    /**
+     * Attempts to halt the test and ignore it if Throwable <code>e</code> is
+     * not <code>null</code>. Similar to {@link #assumeNoException(Throwable)},
+     * but provides an additional message that can explain the details
+     * concerning the assumption.
+     *
+     * @param e if non-null, the offending exception
+     * @param message Additional message to pass to {@link AssumptionViolatedException}.
+     * @see #assumeNoException(Throwable)
+     */
+    public static void assumeNoException(String message, Throwable e) {
+        assumeThat(message, e, nullValue());
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/AssumptionViolatedException.java b/google3/third_party/java_src/junit/main/java/org/junit/AssumptionViolatedException.java
new file mode 100644
index 0000000..1d62190
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/AssumptionViolatedException.java
@@ -0,0 +1,46 @@
+package org.junit;
+
+import org.hamcrest.Matcher;
+
+/**
+ * An exception class used to implement <i>assumptions</i> (state in which a given test
+ * is meaningful and should or should not be executed). A test for which an assumption
+ * fails should not generate a test case failure.
+ *
+ * @see org.junit.Assume
+ * @since 4.12
+ */
+@SuppressWarnings("deprecation")
+public class AssumptionViolatedException extends org.junit.internal.AssumptionViolatedException {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * An assumption exception with the given <i>actual</i> value and a <i>matcher</i> describing 
+     * the expectation that failed.
+     */
+    public <T> AssumptionViolatedException(T actual, Matcher<T> matcher) {
+        super(actual, matcher);
+    }
+
+    /**
+     * An assumption exception with a message with the given <i>actual</i> value and a
+     * <i>matcher</i> describing the expectation that failed.
+     */
+    public <T> AssumptionViolatedException(String message, T expected, Matcher<T> matcher) {
+        super(message, expected, matcher);
+    }
+
+    /**
+     * An assumption exception with the given message only.
+     */
+    public AssumptionViolatedException(String message) {
+        super(message);
+    }
+
+    /**
+     * An assumption exception with the given message and a cause.
+     */
+    public AssumptionViolatedException(String message, Throwable t) {
+        super(message, t);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/Before.java b/google3/third_party/java_src/junit/main/java/org/junit/Before.java
new file mode 100644
index 0000000..def8adb
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/Before.java
@@ -0,0 +1,39 @@
+package org.junit;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * When writing tests, it is common to find that several tests need similar
+ * objects created before they can run. Annotating a <code>public void</code> method
+ * with <code>&#064;Before</code> causes that method to be run before the {@link org.junit.Test} method.
+ * The <code>&#064;Before</code> methods of superclasses will be run before those of the current class,
+ * unless they are overridden in the current class. No other ordering is defined.
+ * <p>
+ * Here is a simple example:
+ * <pre>
+ * public class Example {
+ *    List empty;
+ *    &#064;Before public void initialize() {
+ *       empty= new ArrayList();
+ *    }
+ *    &#064;Test public void size() {
+ *       ...
+ *    }
+ *    &#064;Test public void remove() {
+ *       ...
+ *    }
+ * }
+ * </pre>
+ *
+ * @see org.junit.BeforeClass
+ * @see org.junit.After
+ * @since 4.0
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface Before {
+}
+
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/BeforeClass.java b/google3/third_party/java_src/junit/main/java/org/junit/BeforeClass.java
new file mode 100644
index 0000000..8183fa0
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/BeforeClass.java
@@ -0,0 +1,37 @@
+package org.junit;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Sometimes several tests need to share computationally expensive setup
+ * (like logging into a database). While this can compromise the independence of
+ * tests, sometimes it is a necessary optimization. Annotating a <code>public static void</code> no-arg method
+ * with <code>@BeforeClass</code> causes it to be run once before any of
+ * the test methods in the class. The <code>@BeforeClass</code> methods of superclasses
+ * will be run before those of the current class, unless they are shadowed in the current class.
+ * <p>
+ * For example:
+ * <pre>
+ * public class Example {
+ *    &#064;BeforeClass public static void onlyOnce() {
+ *       ...
+ *    }
+ *    &#064;Test public void one() {
+ *       ...
+ *    }
+ *    &#064;Test public void two() {
+ *       ...
+ *    }
+ * }
+ * </pre>
+ *
+ * @see org.junit.AfterClass
+ * @since 4.0
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface BeforeClass {
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/ClassRule.java b/google3/third_party/java_src/junit/main/java/org/junit/ClassRule.java
new file mode 100644
index 0000000..94ee29f
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/ClassRule.java
@@ -0,0 +1,118 @@
+package org.junit;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotates static fields that reference rules or methods that return them. A field must be public,
+ * static, and a subtype of {@link org.junit.rules.TestRule}.  A method must be public static, and return
+ * a subtype of {@link org.junit.rules.TestRule}.
+ * <p>
+ * The {@link org.junit.runners.model.Statement} passed
+ * to the {@link org.junit.rules.TestRule} will run any {@link BeforeClass} methods,
+ * then the entire body of the test class (all contained methods, if it is
+ * a standard JUnit test class, or all contained classes, if it is a
+ * {@link org.junit.runners.Suite}), and finally any {@link AfterClass} methods.
+ * <p>
+ * The statement passed to the {@link org.junit.rules.TestRule} will never throw an exception,
+ * and throwing an exception from the {@link org.junit.rules.TestRule} will result in undefined
+ * behavior.  This means that some {@link org.junit.rules.TestRule}s, such as
+ * {@link org.junit.rules.ErrorCollector},
+ * {@link org.junit.rules.ExpectedException},
+ * and {@link org.junit.rules.Timeout},
+ * have undefined behavior when used as {@link ClassRule}s.
+ * <p>
+ * If there are multiple
+ * annotated {@link ClassRule}s on a class, they will be applied in an order
+ * that depends on your JVM's implementation of the reflection API, which is
+ * undefined, in general. However, Rules defined by fields will always be applied
+ * after Rules defined by methods, i.e. the Statements returned by the former will
+ * be executed around those returned by the latter.
+ *
+ * <h3>Usage</h3>
+ * <p>
+ * For example, here is a test suite that connects to a server once before
+ * all the test classes run, and disconnects after they are finished:
+ * <pre>
+ * &#064;RunWith(Suite.class)
+ * &#064;SuiteClasses({A.class, B.class, C.class})
+ * public class UsesExternalResource {
+ *     public static Server myServer= new Server();
+ *
+ *     &#064;ClassRule
+ *     public static ExternalResource resource= new ExternalResource() {
+ *       &#064;Override
+ *       protected void before() throws Throwable {
+ *          myServer.connect();
+ *      }
+ *
+ *      &#064;Override
+ *      protected void after() {
+ * 	        myServer.disconnect();
+ *      }
+ *   };
+ * }
+ * </pre>
+ * <p>
+ * and the same using a method
+ * <pre>
+ * &#064;RunWith(Suite.class)
+ * &#064;SuiteClasses({A.class, B.class, C.class})
+ * public class UsesExternalResource {
+ *     public static Server myServer= new Server();
+ *
+ *     &#064;ClassRule
+ *     public static ExternalResource getResource() {
+ *         return new ExternalResource() {
+ *             &#064;Override
+ *             protected void before() throws Throwable {
+ *                 myServer.connect();
+ *             }
+ *
+ *             &#064;Override
+ *             protected void after() {
+ *                 myServer.disconnect();
+ *             }
+ *         };
+ *     }
+ * }
+ * </pre>
+ * <p>
+ * For more information and more examples, see {@link org.junit.rules.TestRule}.
+ *
+ * <h3>Ordering</h3>
+ * <p>
+ * You can use {@link #order()} if you want to have control over the order in
+ * which the Rules are applied.
+ *
+ * <pre>
+ * public class ThreeClassRules {
+ *     &#064;ClassRule(order = 0)
+ *     public static LoggingRule outer = new LoggingRule("outer rule");
+ *
+ *     &#064;ClassRule(order = 1)
+ *     public static LoggingRule middle = new LoggingRule("middle rule");
+ *
+ *     &#064;ClassRule(order = 2)
+ *     public static LoggingRule inner = new LoggingRule("inner rule");
+ *
+ *     // ...
+ * }
+ * </pre>
+ *
+ * @since 4.9
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.METHOD})
+public @interface ClassRule {
+
+    /**
+     * Specifies the order in which rules are applied. The rules with a higher value are inner.
+     *
+     * @since 4.13
+     */
+    int order() default Rule.DEFAULT_ORDER;
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/ComparisonFailure.java b/google3/third_party/java_src/junit/main/java/org/junit/ComparisonFailure.java
new file mode 100644
index 0000000..d1daa86
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/ComparisonFailure.java
@@ -0,0 +1,171 @@
+package org.junit;
+
+/**
+ * Thrown when an {@link org.junit.Assert#assertEquals(Object, Object) assertEquals(String, String)} fails.
+ * Create and throw a <code>ComparisonFailure</code> manually if you want to show users the
+ * difference between two complex strings.
+ * <p/>
+ * Inspired by a patch from Alex Chaffee (alex@purpletech.com)
+ *
+ * @since 4.0
+ */
+public class ComparisonFailure extends AssertionError {
+    /**
+     * The maximum length for expected and actual strings. If it is exceeded, the strings should be shortened.
+     *
+     * @see ComparisonCompactor
+     */
+    private static final int MAX_CONTEXT_LENGTH = 20;
+    private static final long serialVersionUID = 1L;
+
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit4/issues/976
+     */
+    private String fExpected;
+    private String fActual;
+
+    /**
+     * Constructs a comparison failure.
+     *
+     * @param message the identifying message or null
+     * @param expected the expected string value
+     * @param actual the actual string value
+     */
+    public ComparisonFailure(String message, String expected, String actual) {
+        super(message);
+        this.fExpected = expected;
+        this.fActual = actual;
+    }
+
+    /**
+     * Returns "..." in place of common prefix and "..." in place of common suffix between expected and actual.
+     *
+     * @see Throwable#getMessage()
+     */
+    @Override
+    public String getMessage() {
+        return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage());
+    }
+
+    /**
+     * Returns the actual string value
+     *
+     * @return the actual string value
+     */
+    public String getActual() {
+        return fActual;
+    }
+
+    /**
+     * Returns the expected string value
+     *
+     * @return the expected string value
+     */
+    public String getExpected() {
+        return fExpected;
+    }
+
+    private static class ComparisonCompactor {
+        private static final String ELLIPSIS = "...";
+        private static final String DIFF_END = "]";
+        private static final String DIFF_START = "[";
+
+        /**
+         * The maximum length for <code>expected</code> and <code>actual</code> strings to show. When
+         * <code>contextLength</code> is exceeded, the Strings are shortened.
+         */
+        private final int contextLength;
+        private final String expected;
+        private final String actual;
+
+        /**
+         * @param contextLength the maximum length of context surrounding the difference between the compared strings.
+         * When context length is exceeded, the prefixes and suffixes are compacted.
+         * @param expected the expected string value
+         * @param actual the actual string value
+         */
+        public ComparisonCompactor(int contextLength, String expected, String actual) {
+            this.contextLength = contextLength;
+            this.expected = expected;
+            this.actual = actual;
+        }
+
+        public String compact(String message) {
+            if (expected == null || actual == null || expected.equals(actual)) {
+                return Assert.format(message, expected, actual);
+            } else {
+                DiffExtractor extractor = new DiffExtractor();
+                String compactedPrefix = extractor.compactPrefix();
+                String compactedSuffix = extractor.compactSuffix();
+                return Assert.format(message,
+                        compactedPrefix + extractor.expectedDiff() + compactedSuffix,
+                        compactedPrefix + extractor.actualDiff() + compactedSuffix);
+            }
+        }
+
+        private String sharedPrefix() {
+            int end = Math.min(expected.length(), actual.length());
+            for (int i = 0; i < end; i++) {
+                if (expected.charAt(i) != actual.charAt(i)) {
+                    return expected.substring(0, i);
+                }
+            }
+            return expected.substring(0, end);
+        }
+
+        private String sharedSuffix(String prefix) {
+            int suffixLength = 0;
+            int maxSuffixLength = Math.min(expected.length() - prefix.length(),
+                    actual.length() - prefix.length()) - 1;
+            for (; suffixLength <= maxSuffixLength; suffixLength++) {
+                if (expected.charAt(expected.length() - 1 - suffixLength)
+                        != actual.charAt(actual.length() - 1 - suffixLength)) {
+                    break;
+                }
+            }
+            return expected.substring(expected.length() - suffixLength);
+        }
+
+        private class DiffExtractor {
+            private final String sharedPrefix;
+            private final String sharedSuffix;
+
+            /**
+             * Can not be instantiated outside {@link org.junit.ComparisonFailure.ComparisonCompactor}.
+             */
+            private DiffExtractor() {
+                sharedPrefix = sharedPrefix();
+                sharedSuffix = sharedSuffix(sharedPrefix);
+            }
+
+            public String expectedDiff() {
+                return extractDiff(expected);
+            }
+
+            public String actualDiff() {
+                return extractDiff(actual);
+            }
+
+            public String compactPrefix() {
+                if (sharedPrefix.length() <= contextLength) {
+                    return sharedPrefix;
+                }
+                return ELLIPSIS + sharedPrefix.substring(sharedPrefix.length() - contextLength);
+            }
+
+            public String compactSuffix() {
+                if (sharedSuffix.length() <= contextLength) {
+                    return sharedSuffix;
+                }
+                return sharedSuffix.substring(0, contextLength) + ELLIPSIS;
+            }
+
+            private String extractDiff(String source) {
+                return DIFF_START + source.substring(sharedPrefix.length(), source.length() - sharedSuffix.length())
+                        + DIFF_END;
+            }
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/FixMethodOrder.java b/google3/third_party/java_src/junit/main/java/org/junit/FixMethodOrder.java
new file mode 100644
index 0000000..aaa0313
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/FixMethodOrder.java
@@ -0,0 +1,41 @@
+package org.junit;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.junit.runners.MethodSorters;
+
+/**
+ * This class allows the user to choose the order of execution of the methods within a test class.
+ *
+ * <p>The default order of execution of JUnit tests within a class is deterministic but not predictable.
+ * The order of execution is not guaranteed for Java 7 (and some previous versions), and can even change
+ * from run to run, so the order of execution was changed to be deterministic (in JUnit 4.11)
+ *
+ * <p>It is recommended that test methods be written so that they are independent of the order that they are executed.
+ * However, there may be a number of dependent tests either through error or by design.
+ * This class allows the user to specify the order of execution of test methods.
+ *
+ * <p>For possibilities, see {@link MethodSorters}
+ *
+ * Here is an example:
+ *
+ * <pre>
+ * &#064;FixMethodOrder(MethodSorters.NAME_ASCENDING)
+ * public class MyTest {
+ * }
+ * </pre>
+ *
+ * @see org.junit.runners.MethodSorters
+ * @since 4.11
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface FixMethodOrder {
+    /**
+     * Optionally specify <code>value</code> to have the methods executed in a particular order
+     */
+    MethodSorters value() default MethodSorters.DEFAULT;
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/Ignore.java b/google3/third_party/java_src/junit/main/java/org/junit/Ignore.java
new file mode 100644
index 0000000..db23581
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/Ignore.java
@@ -0,0 +1,40 @@
+package org.junit;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Sometimes you want to temporarily disable a test or a group of tests. Methods annotated with
+ * {@link org.junit.Test} that are also annotated with <code>&#064;Ignore</code> will not be executed as tests.
+ * Also, you can annotate a class containing test methods with <code>&#064;Ignore</code> and none of the containing
+ * tests will be executed. Native JUnit 4 test runners should report the number of ignored tests along with the
+ * number of tests that ran and the number of tests that failed.
+ *
+ * <p>For example:
+ * <pre>
+ *    &#064;Ignore &#064;Test public void something() { ...
+ * </pre>
+ * &#064;Ignore takes an optional default parameter if you want to record why a test is being ignored:
+ * <pre>
+ *    &#064;Ignore("not ready yet") &#064;Test public void something() { ...
+ * </pre>
+ * &#064;Ignore can also be applied to the test class:
+ * <pre>
+ *      &#064;Ignore public class IgnoreMe {
+ *          &#064;Test public void test1() { ... }
+ *          &#064;Test public void test2() { ... }
+ *         }
+ * </pre>
+ *
+ * @since 4.0
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD, ElementType.TYPE})
+public @interface Ignore {
+    /**
+     * The optional reason why the test is ignored.
+     */
+    String value() default "";
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/Rule.java b/google3/third_party/java_src/junit/main/java/org/junit/Rule.java
new file mode 100644
index 0000000..9370e94
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/Rule.java
@@ -0,0 +1,101 @@
+package org.junit;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotates fields that reference rules or methods that return a rule. A field must be public, not
+ * static, and a subtype of {@link org.junit.rules.TestRule} (preferred) or
+ * {@link org.junit.rules.MethodRule}. A method must be public, not static,
+ * and must return a subtype of {@link org.junit.rules.TestRule} (preferred) or
+ * {@link org.junit.rules.MethodRule}.
+ * <p>
+ * The {@link org.junit.runners.model.Statement} passed
+ * to the {@link org.junit.rules.TestRule} will run any {@link Before} methods,
+ * then the {@link Test} method, and finally any {@link After} methods,
+ * throwing an exception if any of these fail.  If there are multiple
+ * annotated {@link Rule}s on a class, they will be applied in order of methods first, then fields.
+ * However, if there are multiple fields (or methods) they will be applied in an order
+ * that depends on your JVM's implementation of the reflection API, which is
+ * undefined, in general. Rules defined by fields will always be applied
+ * after Rules defined by methods, i.e. the Statements returned by the former will
+ * be executed around those returned by the latter.
+ *
+ * <h3>Usage</h3>
+ * <p>
+ * For example, here is a test class that creates a temporary folder before
+ * each test method, and deletes it after each:
+ * <pre>
+ * public static class HasTempFolder {
+ *     &#064;Rule
+ *     public TemporaryFolder folder= new TemporaryFolder();
+ *
+ *     &#064;Test
+ *     public void testUsingTempFolder() throws IOException {
+ *         File createdFile= folder.newFile(&quot;myfile.txt&quot;);
+ *         File createdFolder= folder.newFolder(&quot;subfolder&quot;);
+ *         // ...
+ *     }
+ * }
+ * </pre>
+ * <p>
+ * And the same using a method.
+ * <pre>
+ * public static class HasTempFolder {
+ *     private TemporaryFolder folder= new TemporaryFolder();
+ *
+ *     &#064;Rule
+ *     public TemporaryFolder getFolder() {
+ *         return folder;
+ *     }
+ *
+ *     &#064;Test
+ *     public void testUsingTempFolder() throws IOException {
+ *         File createdFile= folder.newFile(&quot;myfile.txt&quot;);
+ *         File createdFolder= folder.newFolder(&quot;subfolder&quot;);
+ *         // ...
+ *     }
+ * }
+ * </pre>
+ * <p>
+ * For more information and more examples, see
+ * {@link org.junit.rules.TestRule}.
+ *
+ * <h3>Ordering</h3>
+ * <p>
+ * You can use {@link #order()} if you want to have control over the order in
+ * which the Rules are applied.
+ *
+ * <pre>
+ * public class ThreeRules {
+ *     &#064;Rule(order = 0)
+ *     public LoggingRule outer = new LoggingRule("outer rule");
+ *
+ *     &#064;Rule(order = 1)
+ *     public LoggingRule middle = new LoggingRule("middle rule");
+ *
+ *     &#064;Rule(order = 2)
+ *     public LoggingRule inner = new LoggingRule("inner rule");
+ *
+ *     // ...
+ * }
+ * </pre>
+ *
+ * @since 4.7
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.METHOD})
+public @interface Rule {
+
+    int DEFAULT_ORDER = -1;
+
+    /**
+     * Specifies the order in which rules are applied. The rules with a higher value are inner.
+     *
+     * @since 4.13
+     */
+    int order() default DEFAULT_ORDER;
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/Test.java b/google3/third_party/java_src/junit/main/java/org/junit/Test.java
new file mode 100644
index 0000000..1db6fc7
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/Test.java
@@ -0,0 +1,117 @@
+package org.junit;
+
+import org.junit.function.ThrowingRunnable;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * The <code>Test</code> annotation tells JUnit that the <code>public void</code> method
+ * to which it is attached can be run as a test case. To run the method,
+ * JUnit first constructs a fresh instance of the class then invokes the
+ * annotated method. Any exceptions thrown by the test will be reported
+ * by JUnit as a failure. If no exceptions are thrown, the test is assumed
+ * to have succeeded.
+ * <p>
+ * A simple test looks like this:
+ * <pre>
+ * public class Example {
+ *    <b>&#064;Test</b>
+ *    public void method() {
+ *       org.junit.Assert.assertTrue( new ArrayList().isEmpty() );
+ *    }
+ * }
+ * </pre>
+ * <p>
+ * The <code>Test</code> annotation supports two optional parameters for
+ * exception testing and for limiting test execution time.
+ *
+ * <h3>Exception Testing</h3>
+ * <p>
+ * The parameter <code>expected</code> declares that a test method should throw
+ * an exception. If it doesn't throw an exception or if it throws a different exception
+ * than the one declared, the test fails. For example, the following test succeeds:
+ * <pre>
+ *    &#064;Test(<b>expected=IndexOutOfBoundsException.class</b>)
+ *    public void outOfBounds() {
+ *       new ArrayList&lt;Object&gt;().get(1);
+ *    }
+ * </pre>
+ *
+ * Using the parameter <code>expected</code> for exception testing comes with
+ * some limitations: only the exception's type can be checked and it is not
+ * possible to precisely specify the code that throws the exception. Therefore
+ * JUnit 4 has improved its support for exception testing with
+ * {@link Assert#assertThrows(Class, ThrowingRunnable)} and the
+ * {@link org.junit.rules.ExpectedException ExpectedException} rule.
+ * With <code>assertThrows</code> the code that throws the exception can be
+ * precisely specified. If the exception's message or one of its properties
+ * should be verified, the <code>ExpectedException</code> rule can be used. Further
+ * information about exception testing can be found at the
+ * <a href="https://github.com/junit-team/junit4/wiki/Exception-testing">JUnit Wiki</a>.
+ *
+ * <h3>Timeout</h3>
+ * <p>
+ * The parameter <code>timeout</code> causes a test to fail if it takes
+ * longer than a specified amount of clock time (measured in milliseconds). The following test fails:
+ * <pre>
+ *    &#064;Test(<b>timeout=100</b>)
+ *    public void infinity() {
+ *       while(true);
+ *    }
+ * </pre>
+ * <b>Warning</b>: while <code>timeout</code> is useful to catch and terminate
+ * infinite loops, it should <em>not</em> be considered deterministic. The
+ * following test may or may not fail depending on how the operating system
+ * schedules threads:
+ * <pre>
+ *    &#064;Test(<b>timeout=100</b>)
+ *    public void sleep100() {
+ *       Thread.sleep(100);
+ *    }
+ * </pre>
+ * <b>THREAD SAFETY WARNING:</b> Test methods with a timeout parameter are run in a thread other than the
+ * thread which runs the fixture's @Before and @After methods. This may yield different behavior for
+ * code that is not thread safe when compared to the same test method without a timeout parameter.
+ * <b>Consider using the {@link org.junit.rules.Timeout} rule instead</b>, which ensures a test method is run on the
+ * same thread as the fixture's @Before and @After methods.
+ *
+ * @since 4.0
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+public @interface Test {
+
+    /**
+     * Default empty exception.
+     */
+    static class None extends Throwable {
+        private static final long serialVersionUID = 1L;
+
+        private None() {
+        }
+    }
+
+    /**
+     * Optionally specify <code>expected</code>, a Throwable, to cause a test method to succeed if
+     * and only if an exception of the specified class is thrown by the method. If the Throwable's
+     * message or one of its properties should be verified, the
+     * {@link org.junit.rules.ExpectedException ExpectedException} rule can be used instead.
+     */
+    Class<? extends Throwable> expected() default None.class;
+
+    /**
+     * Optionally specify <code>timeout</code> in milliseconds to cause a test method to fail if it
+     * takes longer than that number of milliseconds.
+     * <p>
+     * <b>THREAD SAFETY WARNING:</b> Test methods with a timeout parameter are run in a thread other than the
+     * thread which runs the fixture's @Before and @After methods. This may yield different behavior for
+     * code that is not thread safe when compared to the same test method without a timeout parameter.
+     * <b>Consider using the {@link org.junit.rules.Timeout} rule instead</b>, which ensures a test method is run on the
+     * same thread as the fixture's @Before and @After methods.
+     * </p>
+     */
+    long timeout() default 0L;
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/TestCouldNotBeSkippedException.java b/google3/third_party/java_src/junit/main/java/org/junit/TestCouldNotBeSkippedException.java
new file mode 100644
index 0000000..4804493
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/TestCouldNotBeSkippedException.java
@@ -0,0 +1,19 @@
+package org.junit;
+
+/**
+ * Indicates that a test that indicated that it should be skipped could not be skipped.
+ * This can be thrown if a test uses the methods in {@link Assume} to indicate that
+ * it should be skipped, but before processing of the test was completed, other failures
+ * occured.
+ *
+ * @see org.junit.Assume
+ * @since 4.13
+ */
+public class TestCouldNotBeSkippedException extends RuntimeException {
+    private static final long serialVersionUID = 1L;
+
+    /** Creates an instance using the given assumption failure. */
+    public TestCouldNotBeSkippedException(org.junit.internal.AssumptionViolatedException cause) {
+        super("Test could not be skipped due to other failures", cause);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/ParallelComputer.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/ParallelComputer.java
new file mode 100644
index 0000000..97da0f7
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/ParallelComputer.java
@@ -0,0 +1,67 @@
+package org.junit.experimental;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.runner.Computer;
+import org.junit.runner.Runner;
+import org.junit.runners.ParentRunner;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.RunnerBuilder;
+import org.junit.runners.model.RunnerScheduler;
+
+public class ParallelComputer extends Computer {
+    private final boolean classes;
+
+    private final boolean methods;
+
+    public ParallelComputer(boolean classes, boolean methods) {
+        this.classes = classes;
+        this.methods = methods;
+    }
+
+    public static Computer classes() {
+        return new ParallelComputer(true, false);
+    }
+
+    public static Computer methods() {
+        return new ParallelComputer(false, true);
+    }
+
+    private static Runner parallelize(Runner runner) {
+        if (runner instanceof ParentRunner) {
+            ((ParentRunner<?>) runner).setScheduler(new RunnerScheduler() {
+                private final ExecutorService fService = Executors.newCachedThreadPool();
+
+                public void schedule(Runnable childStatement) {
+                    fService.submit(childStatement);
+                }
+
+                public void finished() {
+                    try {
+                        fService.shutdown();
+                        fService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace(System.err);
+                    }
+                }
+            });
+        }
+        return runner;
+    }
+
+    @Override
+    public Runner getSuite(RunnerBuilder builder, java.lang.Class<?>[] classes)
+            throws InitializationError {
+        Runner suite = super.getSuite(builder, classes);
+        return this.classes ? parallelize(suite) : suite;
+    }
+
+    @Override
+    protected Runner getRunner(RunnerBuilder builder, Class<?> testClass)
+            throws Throwable {
+        Runner runner = super.getRunner(builder, testClass);
+        return methods ? parallelize(runner) : runner;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/Categories.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/Categories.java
new file mode 100644
index 0000000..0c73ed8
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/Categories.java
@@ -0,0 +1,375 @@
+package org.junit.experimental.categories;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+import org.junit.runner.Description;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runners.Suite;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.RunnerBuilder;
+
+/**
+ * From a given set of test classes, runs only the classes and methods that are
+ * annotated with either the category given with the @IncludeCategory
+ * annotation, or a subtype of that category.
+ * <p>
+ * Note that, for now, annotating suites with {@code @Category} has no effect.
+ * Categories must be annotated on the direct method or class.
+ * <p>
+ * Example:
+ * <pre>
+ * public interface FastTests {
+ * }
+ *
+ * public interface SlowTests {
+ * }
+ *
+ * public interface SmokeTests
+ * }
+ *
+ * public static class A {
+ *     &#064;Test
+ *     public void a() {
+ *         fail();
+ *     }
+ *
+ *     &#064;Category(SlowTests.class)
+ *     &#064;Test
+ *     public void b() {
+ *     }
+ *
+ *     &#064;Category({FastTests.class, SmokeTests.class})
+ *     &#064;Test
+ *     public void c() {
+ *     }
+ * }
+ *
+ * &#064;Category({SlowTests.class, FastTests.class})
+ * public static class B {
+ *     &#064;Test
+ *     public void d() {
+ *     }
+ * }
+ *
+ * &#064;RunWith(Categories.class)
+ * &#064;IncludeCategory(SlowTests.class)
+ * &#064;SuiteClasses({A.class, B.class})
+ * // Note that Categories is a kind of Suite
+ * public static class SlowTestSuite {
+ *     // Will run A.b and B.d, but not A.a and A.c
+ * }
+ * </pre>
+ * <p>
+ * Example to run multiple categories:
+ * <pre>
+ * &#064;RunWith(Categories.class)
+ * &#064;IncludeCategory({FastTests.class, SmokeTests.class})
+ * &#064;SuiteClasses({A.class, B.class})
+ * public static class FastOrSmokeTestSuite {
+ *     // Will run A.c and B.d, but not A.b because it is not any of FastTests or SmokeTests
+ * }
+ * </pre>
+ *
+ * @version 4.12
+ * @see <a href="https://github.com/junit-team/junit4/wiki/Categories">Categories at JUnit wiki</a>
+ */
+public class Categories extends Suite {
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface IncludeCategory {
+        /**
+         * Determines the tests to run that are annotated with categories specified in
+         * the value of this annotation or their subtypes unless excluded with {@link ExcludeCategory}.
+         */
+        Class<?>[] value() default {};
+
+        /**
+         * If <tt>true</tt>, runs tests annotated with <em>any</em> of the categories in
+         * {@link IncludeCategory#value()}. Otherwise, runs tests only if annotated with <em>all</em> of the categories.
+         */
+        boolean matchAny() default true;
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface ExcludeCategory {
+        /**
+         * Determines the tests which do not run if they are annotated with categories specified in the
+         * value of this annotation or their subtypes regardless of being included in {@link IncludeCategory#value()}.
+         */
+        Class<?>[] value() default {};
+
+        /**
+         * If <tt>true</tt>, the tests annotated with <em>any</em> of the categories in {@link ExcludeCategory#value()}
+         * do not run. Otherwise, the tests do not run if and only if annotated with <em>all</em> categories.
+         */
+        boolean matchAny() default true;
+    }
+
+    public static class CategoryFilter extends Filter {
+        private final Set<Class<?>> included;
+        private final Set<Class<?>> excluded;
+        private final boolean includedAny;
+        private final boolean excludedAny;
+
+        public static CategoryFilter include(boolean matchAny, Class<?>... categories) {
+            return new CategoryFilter(matchAny, categories, true, null);
+        }
+
+        public static CategoryFilter include(Class<?> category) {
+            return include(true, category);
+        }
+
+        public static CategoryFilter include(Class<?>... categories) {
+            return include(true, categories);
+        }
+
+        public static CategoryFilter exclude(boolean matchAny, Class<?>... categories) {
+            return new CategoryFilter(true, null, matchAny, categories);
+        }
+
+        public static CategoryFilter exclude(Class<?> category) {
+            return exclude(true, category);
+        }
+
+        public static CategoryFilter exclude(Class<?>... categories) {
+            return exclude(true, categories);
+        }
+
+        public static CategoryFilter categoryFilter(boolean matchAnyInclusions, Set<Class<?>> inclusions,
+                                                    boolean matchAnyExclusions, Set<Class<?>> exclusions) {
+            return new CategoryFilter(matchAnyInclusions, inclusions, matchAnyExclusions, exclusions);
+        }
+
+        @Deprecated
+        public CategoryFilter(Class<?> includedCategory, Class<?> excludedCategory) {
+            includedAny = true;
+            excludedAny = true;
+            included = nullableClassToSet(includedCategory);
+            excluded = nullableClassToSet(excludedCategory);
+        }
+
+        protected CategoryFilter(boolean matchAnyIncludes, Set<Class<?>> includes,
+                                 boolean matchAnyExcludes, Set<Class<?>> excludes) {
+            includedAny = matchAnyIncludes;
+            excludedAny = matchAnyExcludes;
+            included = copyAndRefine(includes);
+            excluded = copyAndRefine(excludes);
+        }
+
+        private CategoryFilter(boolean matchAnyIncludes, Class<?>[] inclusions,
+                               boolean matchAnyExcludes, Class<?>[] exclusions) {
+            includedAny = matchAnyIncludes; 
+            excludedAny = matchAnyExcludes;
+            included = createSet(inclusions);
+            excluded = createSet(exclusions);
+        }
+
+        /**
+         * @see #toString()
+         */
+        @Override
+        public String describe() {
+            return toString();
+        }
+
+        /**
+         * Returns string in the form <tt>&quot;[included categories] - [excluded categories]&quot;</tt>, where both
+         * sets have comma separated names of categories.
+         *
+         * @return string representation for the relative complement of excluded categories set
+         * in the set of included categories. Examples:
+         * <ul>
+         *  <li> <tt>&quot;categories [all]&quot;</tt> for all included categories and no excluded ones;
+         *  <li> <tt>&quot;categories [all] - [A, B]&quot;</tt> for all included categories and given excluded ones;
+         *  <li> <tt>&quot;categories [A, B] - [C, D]&quot;</tt> for given included categories and given excluded ones.
+         * </ul>
+         * @see Class#toString() name of category
+         */
+        @Override public String toString() {
+            StringBuilder description= new StringBuilder("categories ")
+                .append(included.isEmpty() ? "[all]" : included);
+            if (!excluded.isEmpty()) {
+                description.append(" - ").append(excluded);
+            }
+            return description.toString();
+        }
+
+        @Override
+        public boolean shouldRun(Description description) {
+            if (hasCorrectCategoryAnnotation(description)) {
+                return true;
+            }
+
+            for (Description each : description.getChildren()) {
+                if (shouldRun(each)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private boolean hasCorrectCategoryAnnotation(Description description) {
+            final Set<Class<?>> childCategories= categories(description);
+
+            // If a child has no categories, immediately return.
+            if (childCategories.isEmpty()) {
+                return included.isEmpty();
+            }
+
+            if (!excluded.isEmpty()) {
+                if (excludedAny) {
+                    if (matchesAnyParentCategories(childCategories, excluded)) {
+                        return false;
+                    }
+                } else {
+                    if (matchesAllParentCategories(childCategories, excluded)) {
+                        return false;
+                    }
+                }
+            }
+
+            if (included.isEmpty()) {
+                // Couldn't be excluded, and with no suite's included categories treated as should run.
+                return true;
+            } else {
+                if (includedAny) {
+                    return matchesAnyParentCategories(childCategories, included);
+                } else {
+                    return matchesAllParentCategories(childCategories, included);
+                }
+            }
+        }
+
+        /**
+         * @return <tt>true</tt> if at least one (any) parent category match a child, otherwise <tt>false</tt>.
+         * If empty <tt>parentCategories</tt>, returns <tt>false</tt>.
+         */
+        private boolean matchesAnyParentCategories(Set<Class<?>> childCategories, Set<Class<?>> parentCategories) {
+            for (Class<?> parentCategory : parentCategories) {
+                if (hasAssignableTo(childCategories, parentCategory)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /**
+         * @return <tt>false</tt> if at least one parent category does not match children, otherwise <tt>true</tt>.
+         * If empty <tt>parentCategories</tt>, returns <tt>true</tt>.
+         */
+        private boolean matchesAllParentCategories(Set<Class<?>> childCategories, Set<Class<?>> parentCategories) {
+            for (Class<?> parentCategory : parentCategories) {
+                if (!hasAssignableTo(childCategories, parentCategory)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private static Set<Class<?>> categories(Description description) {
+            Set<Class<?>> categories= new HashSet<Class<?>>();
+            Collections.addAll(categories, directCategories(description));
+            Collections.addAll(categories, directCategories(parentDescription(description)));
+            return categories;
+        }
+
+        private static Description parentDescription(Description description) {
+            Class<?> testClass= description.getTestClass();
+            return testClass == null ? null : Description.createSuiteDescription(testClass);
+        }
+
+        private static Class<?>[] directCategories(Description description) {
+            if (description == null) {
+                return new Class<?>[0];
+            }
+
+            Category annotation= description.getAnnotation(Category.class);
+            return annotation == null ? new Class<?>[0] : annotation.value();
+        }
+
+        private static Set<Class<?>> copyAndRefine(Set<Class<?>> classes) {
+            Set<Class<?>> c= new LinkedHashSet<Class<?>>();
+            if (classes != null) {
+                c.addAll(classes);
+            }
+            c.remove(null);
+            return c;
+        }
+    }
+
+    public Categories(Class<?> klass, RunnerBuilder builder) throws InitializationError {
+        super(klass, builder);
+        try {
+            Set<Class<?>> included= getIncludedCategory(klass);
+            Set<Class<?>> excluded= getExcludedCategory(klass);
+            boolean isAnyIncluded= isAnyIncluded(klass);
+            boolean isAnyExcluded= isAnyExcluded(klass);
+
+            filter(CategoryFilter.categoryFilter(isAnyIncluded, included, isAnyExcluded, excluded));
+        } catch (NoTestsRemainException e) {
+            throw new InitializationError(e);
+        }
+    }
+
+    private static Set<Class<?>> getIncludedCategory(Class<?> klass) {
+        IncludeCategory annotation= klass.getAnnotation(IncludeCategory.class);
+        return createSet(annotation == null ? null : annotation.value());
+    }
+
+    private static boolean isAnyIncluded(Class<?> klass) {
+        IncludeCategory annotation= klass.getAnnotation(IncludeCategory.class);
+        return annotation == null || annotation.matchAny();
+    }
+
+    private static Set<Class<?>> getExcludedCategory(Class<?> klass) {
+        ExcludeCategory annotation= klass.getAnnotation(ExcludeCategory.class);
+        return createSet(annotation == null ? null : annotation.value());
+    }
+
+    private static boolean isAnyExcluded(Class<?> klass) {
+        ExcludeCategory annotation= klass.getAnnotation(ExcludeCategory.class);
+        return annotation == null || annotation.matchAny();
+    }
+
+    private static boolean hasAssignableTo(Set<Class<?>> assigns, Class<?> to) {
+        for (final Class<?> from : assigns) {
+            if (to.isAssignableFrom(from)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static Set<Class<?>> createSet(Class<?>[] classes) {
+        // Not throwing a NPE if t is null is a bad idea, but it's the behavior from JUnit 4.12
+        // for include(boolean, Class<?>...) and exclude(boolean, Class<?>...)
+        if (classes == null || classes.length == 0) {
+            return Collections.emptySet();
+        }
+        for (Class<?> category : classes) {
+            if (category == null) {
+                throw new NullPointerException("has null category");
+            }
+        }
+
+        return classes.length == 1
+            ? Collections.<Class<?>>singleton(classes[0])
+            : new LinkedHashSet<Class<?>>(Arrays.asList(classes));
+    }
+
+    private static Set<Class<?>> nullableClassToSet(Class<?> nullableClass) {
+        // Not throwing a NPE if t is null is a bad idea, but it's the behavior from JUnit 4.11
+        // for CategoryFilter(Class<?> includedCategory, Class<?> excludedCategory)
+        return nullableClass == null
+                ? Collections.<Class<?>>emptySet()
+                : Collections.<Class<?>>singleton(nullableClass);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/Category.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/Category.java
new file mode 100644
index 0000000..8eae836
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/Category.java
@@ -0,0 +1,48 @@
+package org.junit.experimental.categories;
+
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import org.junit.validator.ValidateWith;
+
+/**
+ * Marks a test class or test method as belonging to one or more categories of tests.
+ * The value is an array of arbitrary classes.
+ *
+ * This annotation is only interpreted by the Categories runner (at present).
+ *
+ * For example:
+ * <pre>
+ * public interface FastTests {}
+ * public interface SlowTests {}
+ *
+ * public static class A {
+ * &#064;Test
+ * public void a() {
+ * fail();
+ * }
+ *
+ * &#064;Category(SlowTests.class)
+ * &#064;Test
+ * public void b() {
+ * }
+ * }
+ *
+ * &#064;Category({SlowTests.class, FastTests.class})
+ * public static class B {
+ * &#064;Test
+ * public void c() {
+ *
+ * }
+ * }
+ * </pre>
+ *
+ * For more usage, see code example on {@link Categories}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+@ValidateWith(CategoryValidator.class)
+public @interface Category {
+    Class<?>[] value();
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/CategoryFilterFactory.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/CategoryFilterFactory.java
new file mode 100644
index 0000000..405feeb
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/CategoryFilterFactory.java
@@ -0,0 +1,51 @@
+package org.junit.experimental.categories;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.internal.Classes;
+import org.junit.runner.FilterFactory;
+import org.junit.runner.FilterFactoryParams;
+import org.junit.runner.manipulation.Filter;
+
+/**
+ * Implementation of FilterFactory for Category filtering.
+ */
+abstract class CategoryFilterFactory implements FilterFactory {
+    /**
+     * Creates a {@link org.junit.experimental.categories.Categories.CategoryFilter} given a
+     * {@link FilterFactoryParams} argument.
+     *
+     * @param params Parameters needed to create the {@link Filter}
+     */
+    public Filter createFilter(FilterFactoryParams params) throws FilterNotCreatedException {
+        try {
+            return createFilter(parseCategories(params.getArgs()));
+        } catch (ClassNotFoundException e) {
+            throw new FilterNotCreatedException(e);
+        }
+    }
+
+    /**
+     * Creates a {@link org.junit.experimental.categories.Categories.CategoryFilter} given an array of classes.
+     *
+     * @param categories Category classes.
+     */
+    protected abstract Filter createFilter(List<Class<?>> categories);
+
+    private List<Class<?>> parseCategories(String categories) throws ClassNotFoundException {
+        List<Class<?>> categoryClasses = new ArrayList<Class<?>>();
+
+        for (String category : categories.split(",")) {
+            /*
+             * Load the category class using the context class loader.
+             * If there is no context class loader, use the class loader for this class.
+             */
+            Class<?> categoryClass = Classes.getClass(category, getClass());
+
+            categoryClasses.add(categoryClass);
+        }
+
+        return categoryClasses;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/CategoryValidator.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/CategoryValidator.java
new file mode 100644
index 0000000..491d8ac
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/CategoryValidator.java
@@ -0,0 +1,62 @@
+package org.junit.experimental.categories;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.unmodifiableList;
+import static java.util.Collections.unmodifiableSet;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.validator.AnnotationValidator;
+
+/**
+ * Validates that there are no errors in the use of the {@code Category}
+ * annotation. If there is, a {@code Throwable} object will be added to the list
+ * of errors.
+ *
+ * @since 4.12
+ */
+public final class CategoryValidator extends AnnotationValidator {
+
+    @SuppressWarnings("unchecked")
+    private static final Set<Class<? extends Annotation>> INCOMPATIBLE_ANNOTATIONS = unmodifiableSet(new HashSet<Class<? extends Annotation>>(
+            asList(BeforeClass.class, AfterClass.class, Before.class, After.class)));
+
+    /**
+     * Adds to {@code errors} a throwable for each problem detected. Looks for
+     * {@code BeforeClass}, {@code AfterClass}, {@code Before} and {@code After}
+     * annotations.
+     *
+     * @param method the method that is being validated
+     * @return A list of exceptions detected
+     *
+     * @since 4.12
+     */
+    @Override
+    public List<Exception> validateAnnotatedMethod(FrameworkMethod method) {
+        List<Exception> errors = new ArrayList<Exception>();
+        Annotation[] annotations = method.getAnnotations();
+        for (Annotation annotation : annotations) {
+            for (Class<?> clazz : INCOMPATIBLE_ANNOTATIONS) {
+                if (annotation.annotationType().isAssignableFrom(clazz)) {
+                    addErrorMessage(errors, clazz);
+                }
+            }
+        }
+        return unmodifiableList(errors);
+    }
+
+    private void addErrorMessage(List<Exception> errors, Class<?> clazz) {
+        String message = String.format("@%s can not be combined with @Category",
+                clazz.getSimpleName());
+        errors.add(new Exception(message));
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/ExcludeCategories.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/ExcludeCategories.java
new file mode 100644
index 0000000..5117eef
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/ExcludeCategories.java
@@ -0,0 +1,52 @@
+package org.junit.experimental.categories;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.experimental.categories.Categories.CategoryFilter;
+import org.junit.runner.manipulation.Filter;
+
+/**
+ * {@link org.junit.runner.FilterFactory} to exclude categories.
+ *
+ * The {@link Filter} that is created will filter out tests that are categorized with any of the
+ * given categories.
+ *
+ * Usage from command line:
+ * <code>
+ *     --filter=org.junit.experimental.categories.ExcludeCategories=pkg.of.Cat1,pkg.of.Cat2
+ * </code>
+ *
+ * Usage from API:
+ * <code>
+ *     new ExcludeCategories().createFilter(Cat1.class, Cat2.class);
+ * </code>
+ */
+public final class ExcludeCategories extends CategoryFilterFactory {
+    /**
+     * Creates a {@link Filter} which is only passed by tests that are
+     * not categorized with any of the specified categories.
+     *
+     * @param categories Category classes.
+     */
+    @Override
+    protected Filter createFilter(List<Class<?>> categories) {
+        return new ExcludesAny(categories);
+    }
+
+    private static class ExcludesAny extends CategoryFilter {
+        public ExcludesAny(List<Class<?>> categories) {
+            this(new HashSet<Class<?>>(categories));
+        }
+
+        public ExcludesAny(Set<Class<?>> categories) {
+            super(true, null, true, categories);
+        }
+
+        @Override
+        public String describe() {
+            return "excludes " + super.describe();
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/IncludeCategories.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/IncludeCategories.java
new file mode 100644
index 0000000..b7f7507
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/categories/IncludeCategories.java
@@ -0,0 +1,52 @@
+package org.junit.experimental.categories;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.experimental.categories.Categories.CategoryFilter;
+import org.junit.runner.manipulation.Filter;
+
+/**
+ * {@link org.junit.runner.FilterFactory} to include categories.
+ *
+ * The {@link Filter} that is created will filter out tests that are categorized with any of the
+ * given categories.
+ *
+ * Usage from command line:
+ * <code>
+ *     --filter=org.junit.experimental.categories.IncludeCategories=pkg.of.Cat1,pkg.of.Cat2
+ * </code>
+ *
+ * Usage from API:
+ * <code>
+ *     new IncludeCategories().createFilter(Cat1.class, Cat2.class);
+ * </code>
+ */
+public final class IncludeCategories extends CategoryFilterFactory {
+    /**
+     * Creates a {@link Filter} which is only passed by tests that are
+     * categorized with any of the specified categories.
+     *
+     * @param categories Category classes.
+     */
+    @Override
+    protected Filter createFilter(List<Class<?>> categories) {
+        return new IncludesAny(categories);
+    }
+
+    private static class IncludesAny extends CategoryFilter {
+        public IncludesAny(List<Class<?>> categories) {
+            this(new HashSet<Class<?>>(categories));
+        }
+
+        public IncludesAny(Set<Class<?>> categories) {
+            super(true, categories, true, null);
+        }
+
+        @Override
+        public String describe() {
+            return "includes " + super.describe();
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/max/CouldNotReadCoreException.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/max/CouldNotReadCoreException.java
new file mode 100644
index 0000000..116d755
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/max/CouldNotReadCoreException.java
@@ -0,0 +1,15 @@
+package org.junit.experimental.max;
+
+/**
+ * Thrown when Max cannot read the MaxCore serialization
+ */
+public class CouldNotReadCoreException extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Constructs
+     */
+    public CouldNotReadCoreException(Throwable e) {
+        super(e);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/max/MaxCore.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/max/MaxCore.java
new file mode 100644
index 0000000..625cade
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/max/MaxCore.java
@@ -0,0 +1,181 @@
+package org.junit.experimental.max;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import junit.framework.TestSuite;
+import org.junit.internal.requests.SortingRequest;
+import org.junit.internal.runners.ErrorReportingRunner;
+import org.junit.internal.runners.JUnit38ClassRunner;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.Runner;
+import org.junit.runners.Suite;
+import org.junit.runners.model.InitializationError;
+
+/**
+ * A replacement for JUnitCore, which keeps track of runtime and failure history, and reorders tests
+ * to maximize the chances that a failing test occurs early in the test run.
+ *
+ * The rules for sorting are:
+ * <ol>
+ * <li> Never-run tests first, in arbitrary order
+ * <li> Group remaining tests by the date at which they most recently failed.
+ * <li> Sort groups such that the most recent failure date is first, and never-failing tests are at the end.
+ * <li> Within a group, run the fastest tests first.
+ * </ol>
+ */
+public class MaxCore {
+    private static final String MALFORMED_JUNIT_3_TEST_CLASS_PREFIX = "malformed JUnit 3 test class: ";
+
+    /**
+     * Create a new MaxCore from a serialized file stored at storedResults
+     *
+     * @deprecated use storedLocally()
+     */
+    @Deprecated
+    public static MaxCore forFolder(String folderName) {
+        return storedLocally(new File(folderName));
+    }
+
+    /**
+     * Create a new MaxCore from a serialized file stored at storedResults
+     */
+    public static MaxCore storedLocally(File storedResults) {
+        return new MaxCore(storedResults);
+    }
+
+    private final MaxHistory history;
+
+    private MaxCore(File storedResults) {
+        history = MaxHistory.forFolder(storedResults);
+    }
+
+    /**
+     * Run all the tests in <code>class</code>.
+     *
+     * @return a {@link Result} describing the details of the test run and the failed tests.
+     */
+    public Result run(Class<?> testClass) {
+        return run(Request.aClass(testClass));
+    }
+
+    /**
+     * Run all the tests contained in <code>request</code>.
+     *
+     * @param request the request describing tests
+     * @return a {@link Result} describing the details of the test run and the failed tests.
+     */
+    public Result run(Request request) {
+        return run(request, new JUnitCore());
+    }
+
+    /**
+     * Run all the tests contained in <code>request</code>.
+     *
+     * This variant should be used if {@code core} has attached listeners that this
+     * run should notify.
+     *
+     * @param request the request describing tests
+     * @param core a JUnitCore to delegate to.
+     * @return a {@link Result} describing the details of the test run and the failed tests.
+     */
+    public Result run(Request request, JUnitCore core) {
+        core.addListener(history.listener());
+        return core.run(sortRequest(request).getRunner());
+    }
+
+    /**
+     * @return a new Request, which contains all of the same tests, but in a new order.
+     */
+    public Request sortRequest(Request request) {
+        if (request instanceof SortingRequest) {
+            // We'll pay big karma points for this
+            return request;
+        }
+        List<Description> leaves = findLeaves(request);
+        Collections.sort(leaves, history.testComparator());
+        return constructLeafRequest(leaves);
+    }
+
+    private Request constructLeafRequest(List<Description> leaves) {
+        final List<Runner> runners = new ArrayList<Runner>();
+        for (Description each : leaves) {
+            runners.add(buildRunner(each));
+        }
+        return new Request() {
+            @Override
+            public Runner getRunner() {
+                try {
+                    return new Suite((Class<?>) null, runners) {
+                    };
+                } catch (InitializationError e) {
+                    return new ErrorReportingRunner(null, e);
+                }
+            }
+        };
+    }
+
+    private Runner buildRunner(Description each) {
+        if (each.toString().equals("TestSuite with 0 tests")) {
+            return Suite.emptySuite();
+        }
+        if (each.toString().startsWith(MALFORMED_JUNIT_3_TEST_CLASS_PREFIX)) {
+            // This is cheating, because it runs the whole class
+            // to get the warning for this method, but we can't do better,
+            // because JUnit 3.8's
+            // thrown away which method the warning is for.
+            return new JUnit38ClassRunner(new TestSuite(getMalformedTestClass(each)));
+        }
+        Class<?> type = each.getTestClass();
+        if (type == null) {
+            throw new RuntimeException("Can't build a runner from description [" + each + "]");
+        }
+        String methodName = each.getMethodName();
+        if (methodName == null) {
+            return Request.aClass(type).getRunner();
+        }
+        return Request.method(type, methodName).getRunner();
+    }
+
+    private Class<?> getMalformedTestClass(Description each) {
+        try {
+            return Class.forName(each.toString().replace(MALFORMED_JUNIT_3_TEST_CLASS_PREFIX, ""));
+        } catch (ClassNotFoundException e) {
+            return null;
+        }
+    }
+
+    /**
+     * @param request a request to run
+     * @return a list of method-level tests to run, sorted in the order
+     *         specified in the class comment.
+     */
+    public List<Description> sortedLeavesForTest(Request request) {
+        return findLeaves(sortRequest(request));
+    }
+
+    private List<Description> findLeaves(Request request) {
+        List<Description> results = new ArrayList<Description>();
+        findLeaves(null, request.getRunner().getDescription(), results);
+        return results;
+    }
+
+    private void findLeaves(Description parent, Description description, List<Description> results) {
+        if (description.getChildren().isEmpty()) {
+            if (description.toString().equals("warning(junit.framework.TestSuite$1)")) {
+                results.add(Description.createSuiteDescription(MALFORMED_JUNIT_3_TEST_CLASS_PREFIX + parent));
+            } else {
+                results.add(description);
+            }
+        } else {
+            for (Description each : description.getChildren()) {
+                findLeaves(description, each, results);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/max/MaxHistory.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/max/MaxHistory.java
new file mode 100644
index 0000000..ab7443f
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/max/MaxHistory.java
@@ -0,0 +1,178 @@
+package org.junit.experimental.max;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+
+/**
+ * Stores a subset of the history of each test:
+ * <ul>
+ * <li>Last failure timestamp
+ * <li>Duration of last execution
+ * </ul>
+ */
+public class MaxHistory implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Loads a {@link MaxHistory} from {@code file}, or generates a new one that
+     * will be saved to {@code file}.
+     */
+    public static MaxHistory forFolder(File file) {
+        if (file.exists()) {
+            try {
+                return readHistory(file);
+            } catch (CouldNotReadCoreException e) {
+                e.printStackTrace();
+                file.delete();
+            }
+        }
+        return new MaxHistory(file);
+    }
+
+    private static MaxHistory readHistory(File storedResults)
+            throws CouldNotReadCoreException {
+        try {
+            FileInputStream file = new FileInputStream(storedResults);
+            try {
+                ObjectInputStream stream = new ObjectInputStream(file);
+                try {
+                    return (MaxHistory) stream.readObject();
+                } finally {
+                    stream.close();
+                }
+            } finally {
+                file.close();
+            }
+        } catch (Exception e) {
+            throw new CouldNotReadCoreException(e);
+        }
+    }
+
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit4/issues/976
+     */
+    private final Map<String, Long> fDurations = new HashMap<String, Long>();
+    private final Map<String, Long> fFailureTimestamps = new HashMap<String, Long>();
+    private final File fHistoryStore;
+
+    private MaxHistory(File storedResults) {
+        fHistoryStore = storedResults;
+    }
+
+    private void save() throws IOException {
+        ObjectOutputStream stream = null;
+        try {
+            stream = new ObjectOutputStream(new FileOutputStream(fHistoryStore));
+            stream.writeObject(this);
+        } finally {
+            if (stream != null) {
+                stream.close();
+            }
+        }
+    }
+
+    Long getFailureTimestamp(Description key) {
+        return fFailureTimestamps.get(key.toString());
+    }
+
+    void putTestFailureTimestamp(Description key, long end) {
+        fFailureTimestamps.put(key.toString(), end);
+    }
+
+    boolean isNewTest(Description key) {
+        return !fDurations.containsKey(key.toString());
+    }
+
+    Long getTestDuration(Description key) {
+        return fDurations.get(key.toString());
+    }
+
+    void putTestDuration(Description description, long duration) {
+        fDurations.put(description.toString(), duration);
+    }
+
+    private final class RememberingListener extends RunListener {
+        private long overallStart = System.currentTimeMillis();
+
+        private Map<Description, Long> starts = new HashMap<Description, Long>();
+
+        @Override
+        public void testStarted(Description description) throws Exception {
+            starts.put(description, System.nanoTime()); // Get most accurate
+            // possible time
+        }
+
+        @Override
+        public void testFinished(Description description) throws Exception {
+            long end = System.nanoTime();
+            long start = starts.get(description);
+            putTestDuration(description, end - start);
+        }
+
+        @Override
+        public void testFailure(Failure failure) throws Exception {
+            putTestFailureTimestamp(failure.getDescription(), overallStart);
+        }
+
+        @Override
+        public void testRunFinished(Result result) throws Exception {
+            save();
+        }
+    }
+
+    private class TestComparator implements Comparator<Description> {
+        public int compare(Description o1, Description o2) {
+            // Always prefer new tests
+            if (isNewTest(o1)) {
+                return -1;
+            }
+            if (isNewTest(o2)) {
+                return 1;
+            }
+            // Then most recently failed first
+            int result = getFailure(o2).compareTo(getFailure(o1));
+            return result != 0 ? result
+                    // Then shorter tests first
+                    : getTestDuration(o1).compareTo(getTestDuration(o2));
+        }
+
+        private Long getFailure(Description key) {
+            Long result = getFailureTimestamp(key);
+            if (result == null) {
+                return 0L; // 0 = "never failed (that I know about)"
+            }
+            return result;
+        }
+    }
+
+    /**
+     * @return a listener that will update this history based on the test
+     *         results reported.
+     */
+    public RunListener listener() {
+        return new RememberingListener();
+    }
+
+    /**
+     * @return a comparator that ranks tests based on the JUnit Max sorting
+     *         rules, as described in the {@link MaxCore} class comment.
+     */
+    public Comparator<Description> testComparator() {
+        return new TestComparator();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/results/FailureList.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/results/FailureList.java
new file mode 100644
index 0000000..e02eeae
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/results/FailureList.java
@@ -0,0 +1,28 @@
+package org.junit.experimental.results;
+
+import java.util.List;
+
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+
+class FailureList {
+    private final List<Failure> failures;
+
+    public FailureList(List<Failure> failures) {
+        this.failures = failures;
+    }
+
+    public Result result() {
+        Result result = new Result();
+        RunListener listener = result.createListener();
+        for (Failure failure : failures) {
+            try {
+                listener.testFailure(failure);
+            } catch (Exception e) {
+                throw new RuntimeException("I can't believe this happened");
+            }
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/results/PrintableResult.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/results/PrintableResult.java
new file mode 100644
index 0000000..0f67766
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/results/PrintableResult.java
@@ -0,0 +1,72 @@
+package org.junit.experimental.results;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.List;
+
+import org.junit.internal.TextListener;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+
+/**
+ * A test result that prints nicely in error messages.
+ * This is only intended to be used in JUnit self-tests.
+ * For example:
+ *
+ * <pre>
+ *    assertThat(testResult(HasExpectedException.class), isSuccessful());
+ * </pre>
+ */
+public class PrintableResult {
+    private Result result;
+
+    /**
+     * The result of running JUnit on {@code type}
+     */
+    public static PrintableResult testResult(Class<?> type) {
+        return testResult(Request.aClass(type));
+    }
+
+    /**
+     * The result of running JUnit on Request {@code request}
+     */
+    public static PrintableResult testResult(Request request) {
+        return new PrintableResult(new JUnitCore().run(request));
+    }
+
+    /**
+     * A result that includes the given {@code failures}
+     */
+    public PrintableResult(List<Failure> failures) {
+        this(new FailureList(failures).result());
+    }
+
+    private PrintableResult(Result result) {
+        this.result = result;
+    }
+
+    /**
+     * Returns the number of failures in this result.
+     */
+    public int failureCount() {
+        return result.getFailures().size();
+    }
+
+    /**
+     * Returns the failures in this result.
+     *
+     * @since 4.13
+     */
+    public List<Failure> failures() {
+        return result.getFailures();
+    }
+
+    @Override
+    public String toString() {
+        ByteArrayOutputStream stream = new ByteArrayOutputStream();
+        new TextListener(new PrintStream(stream)).testRunFinished(result);
+        return stream.toString();
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/results/ResultMatchers.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/results/ResultMatchers.java
new file mode 100644
index 0000000..92f2e6b
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/results/ResultMatchers.java
@@ -0,0 +1,99 @@
+package org.junit.experimental.results;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+
+/**
+ * Matchers on a PrintableResult, to enable JUnit self-tests.
+ * For example:
+ *
+ * <pre>
+ * assertThat(testResult(HasExpectedException.class), isSuccessful());
+ * </pre>
+ */
+public class ResultMatchers {
+
+    /**
+     * Do not instantiate.
+     * @deprecated will be private soon.
+     */
+    @Deprecated
+    public ResultMatchers() {
+    }
+
+    /**
+     * Matches if the tests are all successful
+     */
+    public static Matcher<PrintableResult> isSuccessful() {
+        return failureCountIs(0);
+    }
+
+    /**
+     * Matches if there are {@code count} failures
+     */
+    public static Matcher<PrintableResult> failureCountIs(final int count) {
+        return new TypeSafeMatcher<PrintableResult>() {
+            public void describeTo(Description description) {
+                description.appendText("has " + count + " failures");
+            }
+
+            @Override
+            public boolean matchesSafely(PrintableResult item) {
+                return item.failureCount() == count;
+            }
+        };
+    }
+
+    /**
+     * Matches if the result has exactly one failure, and it contains {@code string}
+     */
+    public static Matcher<Object> hasSingleFailureContaining(final String string) {
+        return new BaseMatcher<Object>() {
+            public boolean matches(Object item) {
+                return item.toString().contains(string) && failureCountIs(1).matches(item);
+            }
+
+            public void describeTo(Description description) {
+                description.appendText("has single failure containing " + string);
+            }
+        };
+    }
+
+    /**
+     * Matches if the result has exactly one failure matching the given matcher.
+     *
+     * @since 4.13
+     */
+    public static Matcher<PrintableResult> hasSingleFailureMatching(final Matcher<Throwable> matcher) {
+        return new TypeSafeMatcher<PrintableResult>() {
+            @Override
+            public boolean matchesSafely(PrintableResult item) {
+                return item.failureCount() == 1 && matcher.matches(item.failures().get(0).getException());
+            }
+
+            public void describeTo(Description description) {
+                description.appendText("has failure with exception matching ");
+                matcher.describeTo(description);
+            }
+        };
+    }
+
+    /**
+     * Matches if the result has one or more failures, and at least one of them
+     * contains {@code string}
+     */
+    public static Matcher<PrintableResult> hasFailureContaining(final String string) {
+        return new TypeSafeMatcher<PrintableResult>() {
+            @Override
+            public boolean matchesSafely(PrintableResult item) {
+                return item.failureCount() > 0 && item.toString().contains(string);
+            }
+
+            public void describeTo(Description description) {
+                description.appendText("has failure containing " + string);
+            }
+        };
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/runners/Enclosed.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/runners/Enclosed.java
new file mode 100644
index 0000000..610b970
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/runners/Enclosed.java
@@ -0,0 +1,45 @@
+package org.junit.experimental.runners;
+
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.runners.Suite;
+import org.junit.runners.model.RunnerBuilder;
+
+/**
+ * If you put tests in inner classes, Ant, for example, won't find them. By running the outer class
+ * with Enclosed, the tests in the inner classes will be run. You might put tests in inner classes
+ * to group them for convenience or to share constants. Abstract inner classes are ignored.
+ * <p>
+ * So, for example:
+ * <pre>
+ * &#064;RunWith(Enclosed.class)
+ * public class ListTests {
+ *     ...useful shared stuff...
+ *     public static class OneKindOfListTest {...}
+ *     public static class AnotherKind {...}
+ *     abstract public static class Ignored {...}
+ * }
+ * </pre>
+ */
+public class Enclosed extends Suite {
+    /**
+     * Only called reflectively. Do not use programmatically.
+     */
+    public Enclosed(Class<?> klass, RunnerBuilder builder) throws Throwable {
+        super(builder, klass, filterAbstractClasses(klass.getClasses()));
+    }
+    
+    private static Class<?>[] filterAbstractClasses(final Class<?>[] classes) {     
+        final List<Class<?>> filteredList= new ArrayList<Class<?>>(classes.length);
+
+        for (final Class<?> clazz : classes) {
+            if (!Modifier.isAbstract(clazz.getModifiers())) {
+                filteredList.add(clazz);
+            }
+        }
+        
+        return filteredList.toArray(new Class<?>[filteredList.size()]);
+    }   
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/DataPoint.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/DataPoint.java
new file mode 100644
index 0000000..0a017bb
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/DataPoint.java
@@ -0,0 +1,56 @@
+package org.junit.experimental.theories;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotating an field or method with &#064;DataPoint will cause the field value
+ * or the value returned by the method to be used as a potential parameter for
+ * theories in that class, when run with the
+ * {@link org.junit.experimental.theories.Theories Theories} runner.
+ * <p>
+ * A DataPoint is only considered as a potential value for parameters for
+ * which its type is assignable. When multiple {@code DataPoint}s exist 
+ * with overlapping types more control can be obtained by naming each DataPoint 
+ * using the value of this annotation, e.g. with
+ * <code>&#064;DataPoint({"dataset1", "dataset2"})</code>, and then specifying
+ * which named set to consider as potential values for each parameter using the
+ * {@link org.junit.experimental.theories.FromDataPoints &#064;FromDataPoints}
+ * annotation.
+ * <p>
+ * Parameters with no specified source (i.e. without &#064;FromDataPoints or
+ * other {@link org.junit.experimental.theories.ParametersSuppliedBy
+ * &#064;ParameterSuppliedBy} annotations) will use all {@code DataPoint}s that are
+ * assignable to the parameter type as potential values, including named sets of
+ * {@code DataPoint}s.
+ * 
+ * <pre>
+ * &#064;DataPoint
+ * public static String dataPoint = "value";
+ * 
+ * &#064;DataPoint("generated")
+ * public static String generatedDataPoint() {
+ *     return "generated value";
+ * }
+ * 
+ * &#064;Theory
+ * public void theoryMethod(String param) {
+ *     ...
+ * }
+ * </pre>
+ * 
+ * @see org.junit.experimental.theories.Theories
+ * @see org.junit.experimental.theories.Theory
+ * @see org.junit.experimental.theories.DataPoint
+ * @see org.junit.experimental.theories.FromDataPoints
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({FIELD, METHOD})
+public @interface DataPoint {
+    String[] value() default {};
+    Class<? extends Throwable>[] ignoredExceptions() default {};
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/DataPoints.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/DataPoints.java
new file mode 100644
index 0000000..b47461b
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/DataPoints.java
@@ -0,0 +1,64 @@
+package org.junit.experimental.theories;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotating an array or iterable-typed field or method with &#064;DataPoints
+ * will cause the values in the array or iterable given to be used as potential
+ * parameters for theories in that class when run with the
+ * {@link org.junit.experimental.theories.Theories Theories} runner.
+ * <p>
+ * DataPoints will only be considered as potential values for parameters for
+ * which their types are assignable. When multiple sets of DataPoints exist with
+ * overlapping types more control can be obtained by naming the DataPoints using
+ * the value of this annotation, e.g. with
+ * <code>&#064;DataPoints({"dataset1", "dataset2"})</code>, and then specifying
+ * which named set to consider as potential values for each parameter using the
+ * {@link org.junit.experimental.theories.FromDataPoints &#064;FromDataPoints}
+ * annotation.
+ * <p>
+ * Parameters with no specified source (i.e. without &#064;FromDataPoints or
+ * other {@link org.junit.experimental.theories.ParametersSuppliedBy
+ * &#064;ParameterSuppliedBy} annotations) will use all DataPoints that are
+ * assignable to the parameter type as potential values, including named sets of
+ * DataPoints.
+ * <p>
+ * DataPoints methods whose array types aren't assignable from the target
+ * parameter type (and so can't possibly return relevant values) will not be
+ * called when generating values for that parameter. Iterable-typed datapoints
+ * methods must always be called though, as this information is not available
+ * here after generic type erasure, so expensive methods returning iterable
+ * datapoints are a bad idea.
+ * 
+ * <pre>
+ * &#064;DataPoints
+ * public static String[] dataPoints = new String[] { ... };
+ * 
+ * &#064;DataPoints
+ * public static String[] generatedDataPoints() {
+ *     return new String[] { ... };
+ * }
+ * 
+ * &#064;Theory
+ * public void theoryMethod(String param) {
+ *     ...
+ * }
+ * </pre>
+ * 
+ * @see org.junit.experimental.theories.Theories
+ * @see org.junit.experimental.theories.Theory
+ * @see org.junit.experimental.theories.DataPoint
+ * @see org.junit.experimental.theories.FromDataPoints
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ FIELD, METHOD })
+public @interface DataPoints {
+    String[] value() default {};
+
+    Class<? extends Throwable>[] ignoredExceptions() default {};
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/FromDataPoints.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/FromDataPoints.java
new file mode 100644
index 0000000..2b149ca
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/FromDataPoints.java
@@ -0,0 +1,54 @@
+package org.junit.experimental.theories;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.junit.experimental.theories.internal.SpecificDataPointsSupplier;
+
+/**
+ * Annotating a parameter of a {@link org.junit.experimental.theories.Theory
+ * &#064;Theory} method with <code>&#064;FromDataPoints</code> will limit the
+ * datapoints considered as potential values for that parameter to just the
+ * {@link org.junit.experimental.theories.DataPoints DataPoints} with the given
+ * name. DataPoint names can be given as the value parameter of the
+ * &#064;DataPoints annotation.
+ * <p>
+ * DataPoints without names will not be considered as values for any parameters
+ * annotated with &#064;FromDataPoints.
+ * <pre>
+ * &#064;DataPoints
+ * public static String[] unnamed = new String[] { ... };
+ * 
+ * &#064;DataPoints("regexes")
+ * public static String[] regexStrings = new String[] { ... };
+ * 
+ * &#064;DataPoints({"forMatching", "alphanumeric"})
+ * public static String[] testStrings = new String[] { ... }; 
+ * 
+ * &#064;Theory
+ * public void stringTheory(String param) {
+ *     // This will be called with every value in 'regexStrings',
+ *     // 'testStrings' and 'unnamed'.
+ * }
+ * 
+ * &#064;Theory
+ * public void regexTheory(&#064;FromDataPoints("regexes") String regex,
+ *                         &#064;FromDataPoints("forMatching") String value) {
+ *     // This will be called with only the values in 'regexStrings' as 
+ *     // regex, only the values in 'testStrings' as value, and none 
+ *     // of the values in 'unnamed'.
+ * }
+ * </pre>
+ * 
+ * @see org.junit.experimental.theories.Theory
+ * @see org.junit.experimental.theories.DataPoint
+ * @see org.junit.experimental.theories.DataPoints
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+@ParametersSuppliedBy(SpecificDataPointsSupplier.class)
+public @interface FromDataPoints {
+    String value();
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/ParameterSignature.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/ParameterSignature.java
new file mode 100644
index 0000000..cf22583
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/ParameterSignature.java
@@ -0,0 +1,134 @@
+package org.junit.experimental.theories;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ParameterSignature {
+    
+    private static final Map<Class<?>, Class<?>> CONVERTABLE_TYPES_MAP = buildConvertableTypesMap();
+    
+    private static Map<Class<?>, Class<?>> buildConvertableTypesMap() {
+        Map<Class<?>, Class<?>> map = new HashMap<Class<?>, Class<?>>();
+
+        putSymmetrically(map, boolean.class, Boolean.class);
+        putSymmetrically(map, byte.class, Byte.class);
+        putSymmetrically(map, short.class, Short.class);
+        putSymmetrically(map, char.class, Character.class);
+        putSymmetrically(map, int.class, Integer.class);
+        putSymmetrically(map, long.class, Long.class);
+        putSymmetrically(map, float.class, Float.class);
+        putSymmetrically(map, double.class, Double.class);
+
+        return Collections.unmodifiableMap(map);
+    }
+    
+    private static <T> void putSymmetrically(Map<T, T> map, T a, T b) {
+        map.put(a, b);
+        map.put(b, a);
+    }
+    
+    public static ArrayList<ParameterSignature> signatures(Method method) {
+        return signatures(method.getParameterTypes(), method
+                .getParameterAnnotations());
+    }
+
+    public static List<ParameterSignature> signatures(Constructor<?> constructor) {
+        return signatures(constructor.getParameterTypes(), constructor
+                .getParameterAnnotations());
+    }
+
+    private static ArrayList<ParameterSignature> signatures(
+            Class<?>[] parameterTypes, Annotation[][] parameterAnnotations) {
+        ArrayList<ParameterSignature> sigs = new ArrayList<ParameterSignature>();
+        for (int i = 0; i < parameterTypes.length; i++) {
+            sigs.add(new ParameterSignature(parameterTypes[i],
+                    parameterAnnotations[i]));
+        }
+        return sigs;
+    }
+
+    private final Class<?> type;
+
+    private final Annotation[] annotations;
+
+    private ParameterSignature(Class<?> type, Annotation[] annotations) {
+        this.type = type;
+        this.annotations = annotations;
+    }
+
+    public boolean canAcceptValue(Object candidate) {
+        return (candidate == null) ? !type.isPrimitive() : canAcceptType(candidate.getClass());
+    }
+
+    public boolean canAcceptType(Class<?> candidate) {
+        return type.isAssignableFrom(candidate) ||
+                isAssignableViaTypeConversion(type, candidate);
+    }
+    
+    public boolean canPotentiallyAcceptType(Class<?> candidate) {
+        return candidate.isAssignableFrom(type) ||
+                isAssignableViaTypeConversion(candidate, type) ||
+                canAcceptType(candidate);
+    }
+
+    private boolean isAssignableViaTypeConversion(Class<?> targetType, Class<?> candidate) {
+        if (CONVERTABLE_TYPES_MAP.containsKey(candidate)) {
+            Class<?> wrapperClass = CONVERTABLE_TYPES_MAP.get(candidate);
+            return targetType.isAssignableFrom(wrapperClass);
+        } else {
+            return false;
+        }
+    }
+
+    public Class<?> getType() {
+        return type;
+    }
+
+    public List<Annotation> getAnnotations() {
+        return Arrays.asList(annotations);
+    }
+
+    public boolean hasAnnotation(Class<? extends Annotation> type) {
+        return getAnnotation(type) != null;
+    }
+
+    public <T extends Annotation> T findDeepAnnotation(Class<T> annotationType) {
+        Annotation[] annotations2 = annotations;
+        return findDeepAnnotation(annotations2, annotationType, 3);
+    }
+
+    private <T extends Annotation> T findDeepAnnotation(
+            Annotation[] annotations, Class<T> annotationType, int depth) {
+        if (depth == 0) {
+            return null;
+        }
+        for (Annotation each : annotations) {
+            if (annotationType.isInstance(each)) {
+                return annotationType.cast(each);
+            }
+            Annotation candidate = findDeepAnnotation(each.annotationType()
+                    .getAnnotations(), annotationType, depth - 1);
+            if (candidate != null) {
+                return annotationType.cast(candidate);
+            }
+        }
+
+        return null;
+    }
+
+    public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
+        for (Annotation each : getAnnotations()) {
+            if (annotationType.isInstance(each)) {
+                return annotationType.cast(each);
+            }
+        }
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/ParameterSupplier.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/ParameterSupplier.java
new file mode 100644
index 0000000..bac8b34
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/ParameterSupplier.java
@@ -0,0 +1,43 @@
+package org.junit.experimental.theories;
+
+import java.util.List;
+
+/**
+ * Abstract parent class for suppliers of input data points for theories. Extend this class to customize how {@link
+ * org.junit.experimental.theories.Theories Theories} runner
+ * finds accepted data points. Then use your class together with <b>&#064;ParametersSuppliedBy</b> on input
+ * parameters for theories.
+ *
+ * <p>
+ * For example, here is a supplier for values between two integers, and an annotation that references it:
+ *
+ * <pre>
+ *     &#064;Retention(RetentionPolicy.RUNTIME)
+ *     <b>&#064;ParametersSuppliedBy</b>(BetweenSupplier.class)
+ *     public @interface Between {
+ *         int first();
+ *
+ *         int last();
+ *     }
+ *
+ *     public static class BetweenSupplier extends <b>ParameterSupplier</b> {
+ *         &#064;Override
+ *         public List&lt;<b>PotentialAssignment</b>&gt; getValueSources(<b>ParameterSignature</b> sig) {
+ *             List&lt;<b>PotentialAssignment</b>&gt; list = new ArrayList&lt;PotentialAssignment&gt;();
+ *             Between annotation = (Between) sig.getSupplierAnnotation();
+ *
+ *             for (int i = annotation.first(); i &lt;= annotation.last(); i++)
+ *                 list.add(<b>PotentialAssignment</b>.forValue("ints", i));
+ *             return list;
+ *         }
+ *     }
+ * </pre>
+ * </p>
+ *
+ * @see org.junit.experimental.theories.ParametersSuppliedBy
+ * @see org.junit.experimental.theories.Theories
+ * @see org.junit.experimental.theories.FromDataPoints
+ */
+public abstract class ParameterSupplier {
+    public abstract List<PotentialAssignment> getValueSources(ParameterSignature sig) throws Throwable;
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/ParametersSuppliedBy.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/ParametersSuppliedBy.java
new file mode 100644
index 0000000..846a39e
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/ParametersSuppliedBy.java
@@ -0,0 +1,48 @@
+package org.junit.experimental.theories;
+
+import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
+import static java.lang.annotation.ElementType.PARAMETER;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotating a {@link org.junit.experimental.theories.Theory Theory} method
+ * parameter with &#064;ParametersSuppliedBy causes it to be supplied with
+ * values from the named
+ * {@link org.junit.experimental.theories.ParameterSupplier ParameterSupplier}
+ * when run as a theory by the {@link org.junit.experimental.theories.Theories
+ * Theories} runner.
+ * 
+ * In addition, annotations themselves can be annotated with
+ * &#064;ParametersSuppliedBy, and then used similarly. ParameterSuppliedBy
+ * annotations on parameters are detected by searching up this hierarchy such
+ * that these act as syntactic sugar, making:
+ * 
+ * <pre>
+ * &#064;ParametersSuppliedBy(Supplier.class)
+ * public &#064;interface SpecialParameter { }
+ * 
+ * &#064;Theory
+ * public void theoryMethod(&#064;SpecialParameter String param) {
+ *   ...
+ * }
+ * </pre>
+ * 
+ * equivalent to:
+ * 
+ * <pre>
+ * &#064;Theory
+ * public void theoryMethod(&#064;ParametersSuppliedBy(Supplier.class) String param) {
+ *   ...
+ * }
+ * </pre>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ ANNOTATION_TYPE, PARAMETER })
+public @interface ParametersSuppliedBy {
+
+    Class<? extends ParameterSupplier> value();
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/PotentialAssignment.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/PotentialAssignment.java
new file mode 100644
index 0000000..18ca07a
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/PotentialAssignment.java
@@ -0,0 +1,52 @@
+package org.junit.experimental.theories;
+
+import static java.lang.String.format;
+
+public abstract class PotentialAssignment {
+    public static class CouldNotGenerateValueException extends Exception {
+        private static final long serialVersionUID = 1L;
+        
+        public CouldNotGenerateValueException() {
+        }
+        
+        public CouldNotGenerateValueException(Throwable e) {
+            super(e);
+        }
+    }
+
+    public static PotentialAssignment forValue(final String name, final Object value) {
+        return new PotentialAssignment() {
+            @Override
+            public Object getValue() {
+                return value;
+            }
+
+            @Override
+            public String toString() {
+                return format("[%s]", value);
+            }
+
+            @Override
+            public String getDescription() {
+                String valueString;
+
+                if (value == null) {
+                    valueString = "null";
+                } else {
+                    try {
+                        valueString = format("\"%s\"", value);
+                    } catch (Throwable e) {
+                        valueString = format("[toString() threw %s: %s]", 
+                                             e.getClass().getSimpleName(), e.getMessage());
+                    }
+                }
+
+                return format("%s <from %s>", valueString, name);
+            }
+        };
+    }
+
+    public abstract Object getValue() throws CouldNotGenerateValueException;
+
+    public abstract String getDescription() throws CouldNotGenerateValueException;
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/Theories.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/Theories.java
new file mode 100644
index 0000000..ac88a36
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/Theories.java
@@ -0,0 +1,310 @@
+package org.junit.experimental.theories;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Assume;
+import org.junit.experimental.theories.internal.Assignments;
+import org.junit.experimental.theories.internal.ParameterizedAssertionError;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+import org.junit.runners.model.TestClass;
+
+/**
+ * The Theories runner allows to test a certain functionality against a subset of an infinite set of data points.
+ * <p>
+ * A Theory is a piece of functionality (a method) that is executed against several data inputs called data points.
+ * To make a test method a theory you mark it with <b>&#064;Theory</b>. To create a data point you create a public
+ * field in your test class and mark it with <b>&#064;DataPoint</b>. The Theories runner then executes your test
+ * method as many times as the number of data points declared, providing a different data point as
+ * the input argument on each invocation.
+ * </p>
+ * <p>
+ * A Theory differs from standard test method in that it captures some aspect of the intended behavior in possibly
+ * infinite numbers of scenarios which corresponds to the number of data points declared. Using assumptions and
+ * assertions properly together with covering multiple scenarios with different data points can make your tests more
+ * flexible and bring them closer to scientific theories (hence the name).
+ * </p>
+ * <p>
+ * For example:
+ * <pre>
+ *
+ * &#064;RunWith(<b>Theories.class</b>)
+ * public class UserTest {
+ *      <b>&#064;DataPoint</b>
+ *      public static String GOOD_USERNAME = "optimus";
+ *      <b>&#064;DataPoint</b>
+ *      public static String USERNAME_WITH_SLASH = "optimus/prime";
+ *
+ *      <b>&#064;Theory</b>
+ *      public void filenameIncludesUsername(String username) {
+ *          assumeThat(username, not(containsString("/")));
+ *          assertThat(new User(username).configFileName(), containsString(username));
+ *      }
+ * }
+ * </pre>
+ * This makes it clear that the username should be included in the config file name,
+ * only if it doesn't contain a slash. Another test or theory might define what happens when a username does contain
+ * a slash. <code>UserTest</code> will attempt to run <code>filenameIncludesUsername</code> on every compatible data
+ * point defined in the class. If any of the assumptions fail, the data point is silently ignored. If all of the
+ * assumptions pass, but an assertion fails, the test fails. If no parameters can be found that satisfy all assumptions, the test fails.
+ * <p>
+ * Defining general statements as theories allows data point reuse across a bunch of functionality tests and also
+ * allows automated tools to search for new, unexpected data points that expose bugs.
+ * </p>
+ * <p>
+ * The support for Theories has been absorbed from the Popper project, and more complete documentation can be found
+ * from that projects archived documentation.
+ * </p>
+ *
+ * @see <a href="http://web.archive.org/web/20071012143326/popper.tigris.org/tutorial.html">Archived Popper project documentation</a>
+ * @see <a href="http://web.archive.org/web/20110608210825/http://shareandenjoy.saff.net/tdd-specifications.pdf">Paper on Theories</a>
+ */
+public class Theories extends BlockJUnit4ClassRunner {
+    public Theories(Class<?> klass) throws InitializationError {
+        super(klass);
+    }
+
+    /** @since 4.13 */
+    protected Theories(TestClass testClass) throws InitializationError {
+        super(testClass);
+    }
+
+    @Override
+    protected void collectInitializationErrors(List<Throwable> errors) {
+        super.collectInitializationErrors(errors);
+        validateDataPointFields(errors);
+        validateDataPointMethods(errors);
+    }
+
+    private void validateDataPointFields(List<Throwable> errors) {
+        Field[] fields = getTestClass().getJavaClass().getDeclaredFields();
+
+        for (Field field : fields) {
+            if (field.getAnnotation(DataPoint.class) == null && field.getAnnotation(DataPoints.class) == null) {
+                continue;
+            }
+            if (!Modifier.isStatic(field.getModifiers())) {
+                errors.add(new Error("DataPoint field " + field.getName() + " must be static"));
+            }
+            if (!Modifier.isPublic(field.getModifiers())) {
+                errors.add(new Error("DataPoint field " + field.getName() + " must be public"));
+            }
+        }
+    }
+
+    private void validateDataPointMethods(List<Throwable> errors) {
+        Method[] methods = getTestClass().getJavaClass().getDeclaredMethods();
+        
+        for (Method method : methods) {
+            if (method.getAnnotation(DataPoint.class) == null && method.getAnnotation(DataPoints.class) == null) {
+                continue;
+            }
+            if (!Modifier.isStatic(method.getModifiers())) {
+                errors.add(new Error("DataPoint method " + method.getName() + " must be static"));
+            }
+            if (!Modifier.isPublic(method.getModifiers())) {
+                errors.add(new Error("DataPoint method " + method.getName() + " must be public"));
+            }
+        }
+    }
+
+    @Override
+    protected void validateConstructor(List<Throwable> errors) {
+        validateOnlyOneConstructor(errors);
+    }
+
+    @Override
+    protected void validateTestMethods(List<Throwable> errors) {
+        for (FrameworkMethod each : computeTestMethods()) {
+            if (each.getAnnotation(Theory.class) != null) {
+                each.validatePublicVoid(false, errors);
+                each.validateNoTypeParametersOnArgs(errors);
+            } else {
+                each.validatePublicVoidNoArg(false, errors);
+            }
+            
+            for (ParameterSignature signature : ParameterSignature.signatures(each.getMethod())) {
+                ParametersSuppliedBy annotation = signature.findDeepAnnotation(ParametersSuppliedBy.class);
+                if (annotation != null) {
+                    validateParameterSupplier(annotation.value(), errors);
+                }
+            }
+        }
+    }
+
+    private void validateParameterSupplier(Class<? extends ParameterSupplier> supplierClass, List<Throwable> errors) {
+        Constructor<?>[] constructors = supplierClass.getConstructors();
+        
+        if (constructors.length != 1) {
+            errors.add(new Error("ParameterSupplier " + supplierClass.getName() + 
+                                 " must have only one constructor (either empty or taking only a TestClass)"));
+        } else {
+            Class<?>[] paramTypes = constructors[0].getParameterTypes();
+            if (!(paramTypes.length == 0) && !paramTypes[0].equals(TestClass.class)) {
+                errors.add(new Error("ParameterSupplier " + supplierClass.getName() + 
+                                     " constructor must take either nothing or a single TestClass instance"));
+            }
+        }
+    }
+
+    @Override
+    protected List<FrameworkMethod> computeTestMethods() {
+        List<FrameworkMethod> testMethods = new ArrayList<FrameworkMethod>(super.computeTestMethods());
+        List<FrameworkMethod> theoryMethods = getTestClass().getAnnotatedMethods(Theory.class);
+        testMethods.removeAll(theoryMethods);
+        testMethods.addAll(theoryMethods);
+        return testMethods;
+    }
+
+    @Override
+    public Statement methodBlock(final FrameworkMethod method) {
+        return new TheoryAnchor(method, getTestClass());
+    }
+
+    public static class TheoryAnchor extends Statement {
+        private int successes = 0;
+
+        private final FrameworkMethod testMethod;
+        private final TestClass testClass;
+
+        private List<AssumptionViolatedException> fInvalidParameters = new ArrayList<AssumptionViolatedException>();
+
+        public TheoryAnchor(FrameworkMethod testMethod, TestClass testClass) {
+            this.testMethod = testMethod;
+            this.testClass = testClass;
+        }
+
+        private TestClass getTestClass() {
+            return testClass;
+        }
+
+        @Override
+        public void evaluate() throws Throwable {
+            runWithAssignment(Assignments.allUnassigned(
+                    testMethod.getMethod(), getTestClass()));
+            
+            //if this test method is not annotated with Theory, then no successes is a valid case
+            boolean hasTheoryAnnotation = testMethod.getAnnotation(Theory.class) != null;
+            if (successes == 0 && hasTheoryAnnotation) {
+                Assert
+                        .fail("Never found parameters that satisfied method assumptions.  Violated assumptions: "
+                                + fInvalidParameters);
+            }
+        }
+
+        protected void runWithAssignment(Assignments parameterAssignment)
+                throws Throwable {
+            if (!parameterAssignment.isComplete()) {
+                runWithIncompleteAssignment(parameterAssignment);
+            } else {
+                runWithCompleteAssignment(parameterAssignment);
+            }
+        }
+
+        protected void runWithIncompleteAssignment(Assignments incomplete)
+                throws Throwable {
+            for (PotentialAssignment source : incomplete
+                    .potentialsForNextUnassigned()) {
+                runWithAssignment(incomplete.assignNext(source));
+            }
+        }
+
+        protected void runWithCompleteAssignment(final Assignments complete)
+                throws Throwable {
+            new BlockJUnit4ClassRunner(getTestClass()) {
+                @Override
+                protected void collectInitializationErrors(
+                        List<Throwable> errors) {
+                    // do nothing
+                }
+
+                @Override
+                public Statement methodBlock(FrameworkMethod method) {
+                    final Statement statement = super.methodBlock(method);
+                    return new Statement() {
+                        @Override
+                        public void evaluate() throws Throwable {
+                            try {
+                                statement.evaluate();
+                                handleDataPointSuccess();
+                            } catch (AssumptionViolatedException e) {
+                                handleAssumptionViolation(e);
+                            } catch (Throwable e) {
+                                reportParameterizedError(e, complete
+                                        .getArgumentStrings(nullsOk()));
+                            }
+                        }
+
+                    };
+                }
+
+                @Override
+                protected Statement methodInvoker(FrameworkMethod method, Object test) {
+                    return methodCompletesWithParameters(method, complete, test);
+                }
+
+                @Override
+                public Object createTest() throws Exception {
+                    Object[] params = complete.getConstructorArguments();
+                    
+                    if (!nullsOk()) {
+                        Assume.assumeNotNull(params);
+                    }
+                    
+                    return getTestClass().getOnlyConstructor().newInstance(params);
+                }
+            }.methodBlock(testMethod).evaluate();
+        }
+
+        private Statement methodCompletesWithParameters(
+                final FrameworkMethod method, final Assignments complete, final Object freshInstance) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    final Object[] values = complete.getMethodArguments();
+                    
+                    if (!nullsOk()) {
+                        Assume.assumeNotNull(values);
+                    }
+                    
+                    method.invokeExplosively(freshInstance, values);
+                }
+            };
+        }
+
+        protected void handleAssumptionViolation(AssumptionViolatedException e) {
+            fInvalidParameters.add(e);
+        }
+
+        protected void reportParameterizedError(Throwable e, Object... params)
+                throws Throwable {
+            if (params.length == 0) {
+                throw e;
+            }
+            throw new ParameterizedAssertionError(e, testMethod.getName(),
+                    params);
+        }
+
+        private boolean nullsOk() {
+            Theory annotation = testMethod.getMethod().getAnnotation(
+                    Theory.class);
+            if (annotation == null) {
+                return false;
+            }
+            return annotation.nullsAccepted();
+        }
+
+        protected void handleDataPointSuccess() {
+            successes++;
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/Theory.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/Theory.java
new file mode 100644
index 0000000..0b9f2c4
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/Theory.java
@@ -0,0 +1,18 @@
+package org.junit.experimental.theories;
+
+import static java.lang.annotation.ElementType.METHOD;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks test methods that should be read as theories by the {@link org.junit.experimental.theories.Theories Theories} runner.
+ *
+ * @see org.junit.experimental.theories.Theories
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(METHOD)
+public @interface Theory {
+    boolean nullsAccepted() default true;
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/AllMembersSupplier.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/AllMembersSupplier.java
new file mode 100644
index 0000000..f15fb28
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/AllMembersSupplier.java
@@ -0,0 +1,204 @@
+package org.junit.experimental.theories.internal;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import org.junit.Assume;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.experimental.theories.ParameterSupplier;
+import org.junit.experimental.theories.PotentialAssignment;
+import org.junit.runners.model.FrameworkField;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.TestClass;
+
+/**
+ * Supplies Theory parameters based on all public members of the target class.
+ */
+public class AllMembersSupplier extends ParameterSupplier {
+    static class MethodParameterValue extends PotentialAssignment {
+        private final FrameworkMethod method;
+
+        private MethodParameterValue(FrameworkMethod dataPointMethod) {
+            method = dataPointMethod;
+        }
+
+        @Override
+        public Object getValue() throws CouldNotGenerateValueException {
+            try {
+                return method.invokeExplosively(null);
+            } catch (IllegalArgumentException e) {
+                throw new RuntimeException(
+                        "unexpected: argument length is checked");
+            } catch (IllegalAccessException e) {
+                throw new RuntimeException(
+                        "unexpected: getMethods returned an inaccessible method");
+            } catch (Throwable throwable) {
+                DataPoint annotation = method.getAnnotation(DataPoint.class);
+                Assume.assumeTrue(annotation == null || !isAssignableToAnyOf(annotation.ignoredExceptions(), throwable));
+                
+                throw new CouldNotGenerateValueException(throwable);
+            }
+        }
+
+        @Override
+        public String getDescription() throws CouldNotGenerateValueException {
+            return method.getName();
+        }
+    }
+    
+    private final TestClass clazz;
+
+    /**
+     * Constructs a new supplier for {@code type}
+     */
+    public AllMembersSupplier(TestClass type) {
+        clazz = type;
+    }
+
+    @Override
+    public List<PotentialAssignment> getValueSources(ParameterSignature sig) throws Throwable {
+        List<PotentialAssignment> list = new ArrayList<PotentialAssignment>();
+
+        addSinglePointFields(sig, list);
+        addMultiPointFields(sig, list);
+        addSinglePointMethods(sig, list);
+        addMultiPointMethods(sig, list);
+
+        return list;
+    }
+
+    private void addMultiPointMethods(ParameterSignature sig, List<PotentialAssignment> list) throws Throwable {
+        for (FrameworkMethod dataPointsMethod : getDataPointsMethods(sig)) {
+            Class<?> returnType = dataPointsMethod.getReturnType();
+            
+            if ((returnType.isArray() && sig.canPotentiallyAcceptType(returnType.getComponentType())) ||
+                    Iterable.class.isAssignableFrom(returnType)) {
+                try {
+                    addDataPointsValues(returnType, sig, dataPointsMethod.getName(), list, 
+                            dataPointsMethod.invokeExplosively(null));
+                } catch (Throwable throwable) {
+                    DataPoints annotation = dataPointsMethod.getAnnotation(DataPoints.class);
+                    if (annotation != null && isAssignableToAnyOf(annotation.ignoredExceptions(), throwable)) {
+                        return;
+                    } else {
+                        throw throwable;
+                    }
+                }
+            }
+        }
+    }
+
+    private void addSinglePointMethods(ParameterSignature sig, List<PotentialAssignment> list) {
+        for (FrameworkMethod dataPointMethod : getSingleDataPointMethods(sig)) {
+            if (sig.canAcceptType(dataPointMethod.getType())) {
+                list.add(new MethodParameterValue(dataPointMethod));
+            }
+        }
+    }
+    
+    private void addMultiPointFields(ParameterSignature sig, List<PotentialAssignment> list) {
+        for (final Field field : getDataPointsFields(sig)) {
+            Class<?> type = field.getType();
+            addDataPointsValues(type, sig, field.getName(), list, getStaticFieldValue(field));
+        }
+    }
+
+    private void addSinglePointFields(ParameterSignature sig, List<PotentialAssignment> list) {
+        for (final Field field : getSingleDataPointFields(sig)) {
+            Object value = getStaticFieldValue(field);
+            
+            if (sig.canAcceptValue(value)) {
+                list.add(PotentialAssignment.forValue(field.getName(), value));
+            }
+        }
+    }
+    
+    private void addDataPointsValues(Class<?> type, ParameterSignature sig, String name, 
+            List<PotentialAssignment> list, Object value) {
+        if (type.isArray()) {
+            addArrayValues(sig, name, list, value);
+        }
+        else if (Iterable.class.isAssignableFrom(type)) {
+            addIterableValues(sig, name, list, (Iterable<?>) value);
+        }
+    }
+
+    private void addArrayValues(ParameterSignature sig, String name, List<PotentialAssignment> list, Object array) {
+        for (int i = 0; i < Array.getLength(array); i++) {
+            Object value = Array.get(array, i);
+            if (sig.canAcceptValue(value)) {
+                list.add(PotentialAssignment.forValue(name + "[" + i + "]", value));
+            }
+        }
+    }
+    
+    private void addIterableValues(ParameterSignature sig, String name, List<PotentialAssignment> list, Iterable<?> iterable) {
+        Iterator<?> iterator = iterable.iterator();
+        int i = 0;
+        while (iterator.hasNext()) {
+            Object value = iterator.next();
+            if (sig.canAcceptValue(value)) {
+                list.add(PotentialAssignment.forValue(name + "[" + i + "]", value));
+            }
+            i += 1;
+        }
+    }
+
+    private Object getStaticFieldValue(final Field field) {
+        try {
+            return field.get(null);
+        } catch (IllegalArgumentException e) {
+            throw new RuntimeException(
+                    "unexpected: field from getClass doesn't exist on object");
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(
+                    "unexpected: getFields returned an inaccessible field");
+        }
+    }
+    
+    private static boolean isAssignableToAnyOf(Class<?>[] typeArray, Object target) {
+        for (Class<?> type : typeArray) {
+            if (type.isAssignableFrom(target.getClass())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected Collection<FrameworkMethod> getDataPointsMethods(ParameterSignature sig) {
+        return clazz.getAnnotatedMethods(DataPoints.class);
+    }
+    
+    protected Collection<Field> getSingleDataPointFields(ParameterSignature sig) {
+        List<FrameworkField> fields = clazz.getAnnotatedFields(DataPoint.class);
+        Collection<Field> validFields = new ArrayList<Field>();
+
+        for (FrameworkField frameworkField : fields) {
+            validFields.add(frameworkField.getField());
+        }
+
+        return validFields;
+    }
+    
+    protected Collection<Field> getDataPointsFields(ParameterSignature sig) {
+        List<FrameworkField> fields = clazz.getAnnotatedFields(DataPoints.class);
+        Collection<Field> validFields = new ArrayList<Field>();
+
+        for (FrameworkField frameworkField : fields) {
+            validFields.add(frameworkField.getField());
+        }
+
+        return validFields;
+    }
+    
+    protected Collection<FrameworkMethod> getSingleDataPointMethods(ParameterSignature sig) {
+        return clazz.getAnnotatedMethods(DataPoint.class);
+    }
+
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/Assignments.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/Assignments.java
new file mode 100644
index 0000000..6626797
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/Assignments.java
@@ -0,0 +1,153 @@
+package org.junit.experimental.theories.internal;
+
+import static java.util.Collections.emptyList;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.experimental.theories.ParameterSupplier;
+import org.junit.experimental.theories.ParametersSuppliedBy;
+import org.junit.experimental.theories.PotentialAssignment;
+import org.junit.experimental.theories.PotentialAssignment.CouldNotGenerateValueException;
+import org.junit.runners.model.TestClass;
+
+/**
+ * A potentially incomplete list of value assignments for a method's formal
+ * parameters
+ */
+public class Assignments {
+    private final List<PotentialAssignment> assigned;
+
+    private final List<ParameterSignature> unassigned;
+
+    private final TestClass clazz;
+
+    private Assignments(List<PotentialAssignment> assigned,
+            List<ParameterSignature> unassigned, TestClass clazz) {
+        this.unassigned = unassigned;
+        this.assigned = assigned;
+        this.clazz = clazz;
+    }
+
+    /**
+     * Returns a new assignment list for {@code testMethod}, with no params
+     * assigned.
+     */
+    public static Assignments allUnassigned(Method testMethod,
+            TestClass testClass) {
+        List<ParameterSignature> signatures;
+        signatures = ParameterSignature.signatures(testClass
+                .getOnlyConstructor());
+        signatures.addAll(ParameterSignature.signatures(testMethod));
+        return new Assignments(new ArrayList<PotentialAssignment>(),
+                signatures, testClass);
+    }
+
+    public boolean isComplete() {
+        return unassigned.isEmpty();
+    }
+
+    public ParameterSignature nextUnassigned() {
+        return unassigned.get(0);
+    }
+
+    public Assignments assignNext(PotentialAssignment source) {
+        List<PotentialAssignment> potentialAssignments = new ArrayList<PotentialAssignment>(assigned);
+        potentialAssignments.add(source);
+
+        return new Assignments(potentialAssignments, unassigned.subList(1,
+                unassigned.size()), clazz);
+    }
+
+    public Object[] getActualValues(int start, int stop) 
+            throws CouldNotGenerateValueException {
+        Object[] values = new Object[stop - start];
+        for (int i = start; i < stop; i++) {
+            values[i - start] = assigned.get(i).getValue();
+        }
+        return values;
+    }
+
+    public List<PotentialAssignment> potentialsForNextUnassigned()
+            throws Throwable {
+        ParameterSignature unassigned = nextUnassigned();
+        List<PotentialAssignment> assignments = getSupplier(unassigned).getValueSources(unassigned);
+        
+        if (assignments.isEmpty()) {
+            assignments = generateAssignmentsFromTypeAlone(unassigned);
+        }
+        
+        return assignments;
+    }
+
+    private List<PotentialAssignment> generateAssignmentsFromTypeAlone(ParameterSignature unassigned) {
+        Class<?> paramType = unassigned.getType();
+        
+        if (paramType.isEnum()) {
+            return new EnumSupplier(paramType).getValueSources(unassigned);  
+        } else if (paramType.equals(Boolean.class) || paramType.equals(boolean.class)) {
+            return new BooleanSupplier().getValueSources(unassigned);
+        } else {
+            return emptyList();
+        }
+    }
+
+    private ParameterSupplier getSupplier(ParameterSignature unassigned)
+            throws Exception {
+        ParametersSuppliedBy annotation = unassigned
+                .findDeepAnnotation(ParametersSuppliedBy.class);
+        
+        if (annotation != null) {
+            return buildParameterSupplierFromClass(annotation.value());
+        } else {
+            return new AllMembersSupplier(clazz);
+        }
+    }
+
+    private ParameterSupplier buildParameterSupplierFromClass(
+            Class<? extends ParameterSupplier> cls) throws Exception {
+        Constructor<?>[] supplierConstructors = cls.getConstructors();
+
+        for (Constructor<?> constructor : supplierConstructors) {
+            Class<?>[] parameterTypes = constructor.getParameterTypes();
+            if (parameterTypes.length == 1
+                    && parameterTypes[0].equals(TestClass.class)) {
+                return (ParameterSupplier) constructor.newInstance(clazz);
+            }
+        }
+
+        return cls.newInstance();
+    }
+
+    public Object[] getConstructorArguments()
+            throws CouldNotGenerateValueException {
+        return getActualValues(0, getConstructorParameterCount());
+    }
+
+    public Object[] getMethodArguments() throws CouldNotGenerateValueException {
+        return getActualValues(getConstructorParameterCount(), assigned.size());
+    }
+
+    public Object[] getAllArguments() throws CouldNotGenerateValueException {
+        return getActualValues(0, assigned.size());
+    }
+
+    private int getConstructorParameterCount() {
+        List<ParameterSignature> signatures = ParameterSignature
+                .signatures(clazz.getOnlyConstructor());
+        int constructorParameterCount = signatures.size();
+        return constructorParameterCount;
+    }
+
+    public Object[] getArgumentStrings(boolean nullsOk)
+            throws CouldNotGenerateValueException {
+        Object[] values = new Object[assigned.size()];
+        for (int i = 0; i < values.length; i++) {
+            values[i] = assigned.get(i).getDescription();
+        }
+        return values;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/BooleanSupplier.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/BooleanSupplier.java
new file mode 100644
index 0000000..5f7032f
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/BooleanSupplier.java
@@ -0,0 +1,18 @@
+package org.junit.experimental.theories.internal;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.experimental.theories.ParameterSupplier;
+import org.junit.experimental.theories.PotentialAssignment;
+
+public class BooleanSupplier extends ParameterSupplier {
+
+    @Override
+    public List<PotentialAssignment> getValueSources(ParameterSignature sig) {
+        return Arrays.asList(PotentialAssignment.forValue("true", true),
+                             PotentialAssignment.forValue("false", false));
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/EnumSupplier.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/EnumSupplier.java
new file mode 100644
index 0000000..1f3ab90
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/EnumSupplier.java
@@ -0,0 +1,30 @@
+package org.junit.experimental.theories.internal;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.experimental.theories.ParameterSupplier;
+import org.junit.experimental.theories.PotentialAssignment;
+
+public class EnumSupplier extends ParameterSupplier {
+
+    private Class<?> enumType;
+
+    public EnumSupplier(Class<?> enumType) {
+        this.enumType = enumType;
+    }
+
+    @Override
+    public List<PotentialAssignment> getValueSources(ParameterSignature sig) {
+        Object[] enumValues = enumType.getEnumConstants();
+        
+        List<PotentialAssignment> assignments = new ArrayList<PotentialAssignment>();
+        for (Object value : enumValues) {
+            assignments.add(PotentialAssignment.forValue(value.toString(), value));
+        }
+        
+        return assignments;
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/ParameterizedAssertionError.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/ParameterizedAssertionError.java
new file mode 100644
index 0000000..5b9e947
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/ParameterizedAssertionError.java
@@ -0,0 +1,50 @@
+package org.junit.experimental.theories.internal;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+
+public class ParameterizedAssertionError extends AssertionError {
+    private static final long serialVersionUID = 1L;
+
+    public ParameterizedAssertionError(Throwable targetException,
+            String methodName, Object... params) {
+        super(String.format("%s(%s)", methodName, join(", ", params)));
+        this.initCause(targetException);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof ParameterizedAssertionError && toString().equals(obj.toString());
+    }
+
+    @Override
+    public int hashCode() {
+        return toString().hashCode();
+    }
+
+    public static String join(String delimiter, Object... params) {
+        return join(delimiter, Arrays.asList(params));
+    }
+
+    public static String join(String delimiter, Collection<Object> values) {
+        StringBuilder sb = new StringBuilder();
+        Iterator<Object> iter = values.iterator();
+        while (iter.hasNext()) {
+            Object next = iter.next();
+            sb.append(stringValueOf(next));
+            if (iter.hasNext()) {
+                sb.append(delimiter);
+            }
+        }
+        return sb.toString();
+    }
+
+    private static String stringValueOf(Object next) {
+        try {
+            return String.valueOf(next);
+        } catch (Throwable e) {
+            return "[toString failed]";
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/SpecificDataPointsSupplier.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/SpecificDataPointsSupplier.java
new file mode 100644
index 0000000..7b571e3
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/internal/SpecificDataPointsSupplier.java
@@ -0,0 +1,90 @@
+package org.junit.experimental.theories.internal;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.FromDataPoints;
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.TestClass;
+
+public class SpecificDataPointsSupplier extends AllMembersSupplier {
+
+    public SpecificDataPointsSupplier(TestClass testClass) {
+        super(testClass);
+    }
+    
+    @Override
+    protected Collection<Field> getSingleDataPointFields(ParameterSignature sig) {
+        Collection<Field> fields = super.getSingleDataPointFields(sig);        
+        String requestedName = sig.getAnnotation(FromDataPoints.class).value();
+
+        List<Field> fieldsWithMatchingNames = new ArrayList<Field>();
+        
+        for (Field field : fields) {
+            String[] fieldNames = field.getAnnotation(DataPoint.class).value();
+            if (Arrays.asList(fieldNames).contains(requestedName)) {
+                fieldsWithMatchingNames.add(field);
+            }
+        }
+        
+        return fieldsWithMatchingNames;
+    }
+    
+    @Override
+    protected Collection<Field> getDataPointsFields(ParameterSignature sig) {
+        Collection<Field> fields = super.getDataPointsFields(sig);        
+        String requestedName = sig.getAnnotation(FromDataPoints.class).value();
+        
+        List<Field> fieldsWithMatchingNames = new ArrayList<Field>();
+        
+        for (Field field : fields) {
+            String[] fieldNames = field.getAnnotation(DataPoints.class).value();
+            if (Arrays.asList(fieldNames).contains(requestedName)) {
+                fieldsWithMatchingNames.add(field);
+            }
+        }
+        
+        return fieldsWithMatchingNames;
+    }
+    
+    @Override
+    protected Collection<FrameworkMethod> getSingleDataPointMethods(ParameterSignature sig) {
+        Collection<FrameworkMethod> methods = super.getSingleDataPointMethods(sig);
+        String requestedName = sig.getAnnotation(FromDataPoints.class).value();
+        
+        List<FrameworkMethod> methodsWithMatchingNames = new ArrayList<FrameworkMethod>();
+        
+        for (FrameworkMethod method : methods) {
+            String[] methodNames = method.getAnnotation(DataPoint.class).value();
+            if (Arrays.asList(methodNames).contains(requestedName)) {
+                methodsWithMatchingNames.add(method);
+            }
+        }
+        
+        return methodsWithMatchingNames;
+    }
+    
+    @Override
+    protected Collection<FrameworkMethod> getDataPointsMethods(ParameterSignature sig) {
+        Collection<FrameworkMethod> methods = super.getDataPointsMethods(sig);
+        String requestedName = sig.getAnnotation(FromDataPoints.class).value();
+        
+        List<FrameworkMethod> methodsWithMatchingNames = new ArrayList<FrameworkMethod>();
+        
+        for (FrameworkMethod method : methods) {
+            String[] methodNames = method.getAnnotation(DataPoints.class).value();
+            if (Arrays.asList(methodNames).contains(requestedName)) {
+                methodsWithMatchingNames.add(method);
+            }
+        }
+        
+        return methodsWithMatchingNames;
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/suppliers/TestedOn.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/suppliers/TestedOn.java
new file mode 100644
index 0000000..a19f20a
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/suppliers/TestedOn.java
@@ -0,0 +1,31 @@
+package org.junit.experimental.theories.suppliers;
+
+import static java.lang.annotation.ElementType.PARAMETER;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.junit.experimental.theories.ParametersSuppliedBy;
+
+/**
+ * Annotating a {@link org.junit.experimental.theories.Theory Theory} method int
+ * parameter with &#064;TestedOn causes it to be supplied with values from the
+ * ints array given when run as a theory by the
+ * {@link org.junit.experimental.theories.Theories Theories} runner. For
+ * example, the below method would be called three times by the Theories runner,
+ * once with each of the int parameters specified.
+ * 
+ * <pre>
+ * &#064;Theory
+ * public void shouldPassForSomeInts(&#064;TestedOn(ints={1, 2, 3}) int param) {
+ *     ...
+ * }
+ * </pre>
+ */
+@ParametersSuppliedBy(TestedOnSupplier.class)
+@Retention(RetentionPolicy.RUNTIME)
+@Target(PARAMETER)
+public @interface TestedOn {
+    int[] ints();
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/suppliers/TestedOnSupplier.java b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/suppliers/TestedOnSupplier.java
new file mode 100644
index 0000000..dc3d0c9
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/experimental/theories/suppliers/TestedOnSupplier.java
@@ -0,0 +1,25 @@
+package org.junit.experimental.theories.suppliers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.experimental.theories.ParameterSupplier;
+import org.junit.experimental.theories.PotentialAssignment;
+
+/**
+ * @see org.junit.experimental.theories.suppliers.TestedOn
+ * @see org.junit.experimental.theories.ParameterSupplier
+ */
+public class TestedOnSupplier extends ParameterSupplier {
+    @Override
+    public List<PotentialAssignment> getValueSources(ParameterSignature sig) {
+        List<PotentialAssignment> list = new ArrayList<PotentialAssignment>();
+        TestedOn testedOn = sig.getAnnotation(TestedOn.class);
+        int[] ints = testedOn.ints();
+        for (final int i : ints) {
+            list.add(PotentialAssignment.forValue("ints", i));
+        }
+        return list;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/function/ThrowingRunnable.java b/google3/third_party/java_src/junit/main/java/org/junit/function/ThrowingRunnable.java
new file mode 100644
index 0000000..d0eb782
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/function/ThrowingRunnable.java
@@ -0,0 +1,14 @@
+package org.junit.function;
+
+/**
+ * This interface facilitates the use of
+ * {@link org.junit.Assert#assertThrows(Class, ThrowingRunnable)} from Java 8. It allows method
+ * references to void methods (that declare checked exceptions) to be passed directly into
+ * {@code assertThrows}
+ * without wrapping. It is not meant to be implemented directly.
+ *
+ * @since 4.13
+ */
+public interface ThrowingRunnable {
+    void run() throws Throwable;
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/ArrayComparisonFailure.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/ArrayComparisonFailure.java
new file mode 100644
index 0000000..d300e7e
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/ArrayComparisonFailure.java
@@ -0,0 +1,74 @@
+package org.junit.internal;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Assert;
+
+/**
+ * Thrown when two array elements differ
+ *
+ * @see Assert#assertArrayEquals(String, Object[], Object[])
+ */
+public class ArrayComparisonFailure extends AssertionError {
+
+    private static final long serialVersionUID = 1L;
+
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility.
+     * See https://github.com/junit-team/junit4/issues/976
+     */
+    private final List<Integer> fIndices = new ArrayList<Integer>();
+    private final String fMessage;
+    private final AssertionError fCause;
+
+    /**
+     * Construct a new <code>ArrayComparisonFailure</code> with an error text and the array's
+     * dimension that was not equal
+     *
+     * @param cause the exception that caused the array's content to fail the assertion test
+     * @param index the array position of the objects that are not equal.
+     * @see Assert#assertArrayEquals(String, Object[], Object[])
+     */
+    public ArrayComparisonFailure(String message, AssertionError cause, int index) {
+        this.fMessage = message;
+        this.fCause = cause;
+        initCause(fCause);
+        addDimension(index);
+    }
+
+    public void addDimension(int index) {
+        fIndices.add(0, index);
+    }
+
+    @Override
+    public synchronized Throwable getCause() {
+        return super.getCause() == null ? fCause : super.getCause();
+    }
+
+    @Override
+    public String getMessage() {
+        StringBuilder sb = new StringBuilder();
+        if (fMessage != null) {
+            sb.append(fMessage);
+        }
+        sb.append("arrays first differed at element ");
+        for (int each : fIndices) {
+            sb.append("[");
+            sb.append(each);
+            sb.append("]");
+        }
+        sb.append("; ");
+        sb.append(getCause().getMessage());
+        return sb.toString();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public String toString() {
+        return getMessage();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/AssumptionViolatedException.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/AssumptionViolatedException.java
new file mode 100644
index 0000000..0e79b56
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/AssumptionViolatedException.java
@@ -0,0 +1,139 @@
+package org.junit.internal;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.SelfDescribing;
+import org.hamcrest.StringDescription;
+
+/**
+ * An exception class used to implement <i>assumptions</i> (state in which a given test
+ * is meaningful and should or should not be executed). A test for which an assumption
+ * fails should not generate a test case failure.
+ *
+ * @see org.junit.Assume
+ */
+public class AssumptionViolatedException extends RuntimeException implements SelfDescribing {
+    private static final long serialVersionUID = 2L;
+
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit4/issues/976
+     */
+    private final String fAssumption;
+    private final boolean fValueMatcher;
+    private final Object fValue;
+    private final Matcher<?> fMatcher;
+
+    /**
+     * @deprecated Please use {@link org.junit.AssumptionViolatedException} instead.
+     */
+    @Deprecated
+    public AssumptionViolatedException(String assumption, boolean hasValue, Object value, Matcher<?> matcher) {
+        this.fAssumption = assumption;
+        this.fValue = value;
+        this.fMatcher = matcher;
+        this.fValueMatcher = hasValue;
+
+        if (value instanceof Throwable) {
+          initCause((Throwable) value);
+        }
+    }
+
+    /**
+     * An assumption exception with the given <i>value</i> (String or
+     * Throwable) and an additional failing {@link Matcher}.
+     *
+     * @deprecated Please use {@link org.junit.AssumptionViolatedException} instead.
+     */
+    @Deprecated
+    public AssumptionViolatedException(Object value, Matcher<?> matcher) {
+        this(null, true, value, matcher);
+    }
+
+    /**
+     * An assumption exception with the given <i>value</i> (String or
+     * Throwable) and an additional failing {@link Matcher}.
+     *
+     * @deprecated Please use {@link org.junit.AssumptionViolatedException} instead.
+     */
+    @Deprecated
+    public AssumptionViolatedException(String assumption, Object value, Matcher<?> matcher) {
+        this(assumption, true, value, matcher);
+    }
+
+    /**
+     * An assumption exception with the given message only.
+     *
+     * @deprecated Please use {@link org.junit.AssumptionViolatedException} instead.
+     */
+    @Deprecated
+    public AssumptionViolatedException(String assumption) {
+        this(assumption, false, null, null);
+    }
+
+    /**
+     * An assumption exception with the given message and a cause.
+     *
+     * @deprecated Please use {@link org.junit.AssumptionViolatedException} instead.
+     */
+    @Deprecated
+    public AssumptionViolatedException(String assumption, Throwable e) {
+        this(assumption, false, null, null);
+        initCause(e);
+    }
+
+    @Override
+    public String getMessage() {
+        return StringDescription.asString(this);
+    }
+
+    public void describeTo(Description description) {
+        if (fAssumption != null) {
+            description.appendText(fAssumption);
+        }
+
+        if (fValueMatcher) {
+            // a value was passed in when this instance was constructed; print it
+            if (fAssumption != null) {
+                description.appendText(": ");
+            }
+
+            description.appendText("got: ");
+            description.appendValue(fValue);
+
+            if (fMatcher != null) {
+                description.appendText(", expected: ");
+                description.appendDescriptionOf(fMatcher);
+            }
+        }
+    }
+
+    /**
+     * Override default Java object serialization to correctly deal with potentially unserializable matchers or values.
+     * By not implementing readObject, we assure ourselves of backwards compatibility and compatibility with the
+     * standard way of Java serialization.
+     *
+     * @param objectOutputStream The outputStream to write our representation to
+     * @throws IOException When serialization fails
+     */
+    private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
+        ObjectOutputStream.PutField putField = objectOutputStream.putFields();
+        putField.put("fAssumption", fAssumption);
+        putField.put("fValueMatcher", fValueMatcher);
+
+        // We have to wrap the matcher into a serializable form.
+        putField.put("fMatcher", SerializableMatcherDescription.asSerializableMatcher(fMatcher));
+
+        // We have to wrap the value inside a non-String class (instead of serializing the String value directly) as
+        // A Description will handle a String and non-String object differently (1st is surrounded by '"' while the
+        // latter will be surrounded by '<' '>'. Wrapping it makes sure that the description of a serialized and
+        // non-serialized instance produce the exact same description
+        putField.put("fValue", SerializableValueDescription.asSerializableValue(fValue));
+
+        objectOutputStream.writeFields();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/Checks.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/Checks.java
new file mode 100644
index 0000000..9724947
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/Checks.java
@@ -0,0 +1,37 @@
+package org.junit.internal;
+
+/** @since 4.13 */
+public final class Checks {
+
+    private Checks() {}
+
+    /**
+     * Checks that the given value is not {@code null}.
+     *
+     * @param value object reference to check
+     * @return the passed-in value, if not {@code null}
+     * @throws NullPointerException if {@code value} is {@code null}
+     */
+    public static <T> T notNull(T value) {
+        if (value == null) {
+            throw new NullPointerException();
+        }
+        return value;
+    }
+
+    /**
+     * Checks that the given value is not {@code null}, using the given message
+     * as the exception message if an exception is thrown.
+     *
+     * @param value object reference to check
+     * @param message message to use if {@code value} is {@code null}
+     * @return the passed-in value, if not {@code null}
+     * @throws NullPointerException if {@code value} is {@code null}
+     */
+    public static <T> T notNull(T value, String message) {
+        if (value == null) {
+            throw new NullPointerException(message);
+        }
+        return value;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/Classes.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/Classes.java
new file mode 100644
index 0000000..0693836
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/Classes.java
@@ -0,0 +1,44 @@
+package org.junit.internal;
+
+import static java.lang.Thread.currentThread;
+
+/**
+ * Miscellaneous functions dealing with classes.
+ */
+public class Classes {
+
+    /**
+     * Do not instantiate.
+     * @deprecated will be private soon.
+     */
+    @Deprecated
+    public Classes() {
+    }
+
+    /**
+     * Returns Class.forName for {@code className} using the current thread's class loader.
+     * If the current thread does not have a class loader, falls back to the class loader for
+     * {@link Classes}.
+     *
+     * @param className Name of the class.
+     * @throws ClassNotFoundException
+     */
+    public static Class<?> getClass(String className) throws ClassNotFoundException {
+        return getClass(className, Classes.class);
+    }
+
+    /**
+     * Returns Class.forName for {@code className} using the current thread's class loader.
+     * If the current thread does not have a class loader, falls back to the class loader for the
+     * passed-in class.
+     *
+     * @param className Name of the class.
+     * @param callingClass Class that is requesting a the class
+     * @throws ClassNotFoundException
+     * @since 4.13
+     */
+    public static Class<?> getClass(String className, Class<?> callingClass) throws ClassNotFoundException {
+        ClassLoader classLoader = currentThread().getContextClassLoader();
+        return Class.forName(className, true, classLoader == null ? callingClass.getClassLoader() : classLoader);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/ComparisonCriteria.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/ComparisonCriteria.java
new file mode 100644
index 0000000..ed1c674
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/ComparisonCriteria.java
@@ -0,0 +1,132 @@
+package org.junit.internal;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+import org.junit.Assert;
+
+/**
+ * Defines criteria for finding two items "equal enough". Concrete subclasses
+ * may demand exact equality, or, for example, equality within a given delta.
+ */
+public abstract class ComparisonCriteria {
+    /**
+     * Asserts that two arrays are equal, according to the criteria defined by
+     * the concrete subclass. If they are not, an {@link AssertionError} is
+     * thrown with the given message. If <code>expecteds</code> and
+     * <code>actuals</code> are <code>null</code>, they are considered equal.
+     *
+     * @param message the identifying message for the {@link AssertionError} (
+     * <code>null</code> okay)
+     * @param expecteds Object array or array of arrays (multi-dimensional array) with
+     * expected values.
+     * @param actuals Object array or array of arrays (multi-dimensional array) with
+     * actual values
+     */
+    public void arrayEquals(String message, Object expecteds, Object actuals)
+            throws ArrayComparisonFailure {
+        arrayEquals(message, expecteds, actuals, true);
+    }
+
+    private void arrayEquals(String message, Object expecteds, Object actuals, boolean outer)
+            throws ArrayComparisonFailure {
+        if (expecteds == actuals
+            || Arrays.deepEquals(new Object[] {expecteds}, new Object[] {actuals})) {
+            // The reflection-based loop below is potentially very slow, especially for primitive
+            // arrays. The deepEquals check allows us to circumvent it in the usual case where
+            // the arrays are exactly equal.
+            return;
+        }
+        String header = message == null ? "" : message + ": ";
+
+        // Only include the user-provided message in the outer exception.
+        String exceptionMessage = outer ? header : "";
+
+        if (expecteds == null) {
+            Assert.fail(exceptionMessage + "expected array was null");
+        }
+        if (actuals == null) {
+            Assert.fail(exceptionMessage + "actual array was null");
+        }
+
+        int actualsLength = Array.getLength(actuals);
+        int expectedsLength = Array.getLength(expecteds);
+        if (actualsLength != expectedsLength) {
+            header += "array lengths differed, expected.length="
+                    + expectedsLength + " actual.length=" + actualsLength + "; ";
+        }
+        int prefixLength = Math.min(actualsLength, expectedsLength);
+
+        for (int i = 0; i < prefixLength; i++) {
+            Object expected = Array.get(expecteds, i);
+            Object actual = Array.get(actuals, i);
+
+            if (isArray(expected) && isArray(actual)) {
+                try {
+                    arrayEquals(message, expected, actual, false);
+                } catch (ArrayComparisonFailure e) {
+                    e.addDimension(i);
+                    throw e;
+                } catch (AssertionError e) {
+                    // Array lengths differed.
+                    throw new ArrayComparisonFailure(header, e, i);
+                }
+            } else {
+                try {
+                    assertElementsEqual(expected, actual);
+                } catch (AssertionError e) {
+                    throw new ArrayComparisonFailure(header, e, i);
+                }
+            }
+        }
+
+        if (actualsLength != expectedsLength) {
+            Object expected = getToStringableArrayElement(expecteds, expectedsLength, prefixLength);
+            Object actual = getToStringableArrayElement(actuals, actualsLength, prefixLength);
+            try {
+                Assert.assertEquals(expected, actual);
+            } catch (AssertionError e) {
+                throw new ArrayComparisonFailure(header, e, prefixLength);
+            }
+        }
+    }
+
+    private static final Object END_OF_ARRAY_SENTINEL = objectWithToString("end of array");
+
+    private Object getToStringableArrayElement(Object array, int length, int index) {
+        if (index < length) {
+            Object element = Array.get(array, index);
+            if (isArray(element)) {
+                return objectWithToString(componentTypeName(element.getClass()) + "[" + Array.getLength(element) + "]");
+            } else {
+                return element;
+            }
+        } else {
+            return END_OF_ARRAY_SENTINEL;
+        }
+    }
+
+    private static Object objectWithToString(final String string) {
+        return new Object() {
+            @Override
+            public String toString() {
+                return string;
+            }
+        };
+    }
+
+    private String componentTypeName(Class<?> arrayClass) {
+        Class<?> componentType = arrayClass.getComponentType();
+        if (componentType.isArray()) {
+            return componentTypeName(componentType) + "[]";
+        } else {
+            return componentType.getName();
+        }
+    }
+
+    private boolean isArray(Object expected) {
+        return expected != null && expected.getClass().isArray();
+    }
+
+    protected abstract void assertElementsEqual(Object expected, Object actual);
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/ExactComparisonCriteria.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/ExactComparisonCriteria.java
new file mode 100644
index 0000000..a267f7f
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/ExactComparisonCriteria.java
@@ -0,0 +1,10 @@
+package org.junit.internal;
+
+import org.junit.Assert;
+
+public class ExactComparisonCriteria extends ComparisonCriteria {
+    @Override
+    protected void assertElementsEqual(Object expected, Object actual) {
+        Assert.assertEquals(expected, actual);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/InexactComparisonCriteria.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/InexactComparisonCriteria.java
new file mode 100644
index 0000000..16e804b
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/InexactComparisonCriteria.java
@@ -0,0 +1,24 @@
+package org.junit.internal;
+
+import org.junit.Assert;
+
+public class InexactComparisonCriteria extends ComparisonCriteria {
+    public Object fDelta;
+
+    public InexactComparisonCriteria(double delta) {
+        fDelta = delta;
+    }
+
+    public InexactComparisonCriteria(float delta) {
+        fDelta = delta;
+    }
+
+    @Override
+    protected void assertElementsEqual(Object expected, Object actual) {
+        if (expected instanceof Double) {
+            Assert.assertEquals((Double) expected, (Double) actual, (Double) fDelta);
+        } else {
+            Assert.assertEquals((Float) expected, (Float) actual, (Float) fDelta);
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/JUnitSystem.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/JUnitSystem.java
new file mode 100644
index 0000000..cf0f2c0
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/JUnitSystem.java
@@ -0,0 +1,14 @@
+package org.junit.internal;
+
+import java.io.PrintStream;
+
+public interface JUnitSystem {
+
+    /**
+     * Will be removed in the next major release
+     */
+    @Deprecated
+    void exit(int code);
+
+    PrintStream out();
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/MethodSorter.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/MethodSorter.java
new file mode 100644
index 0000000..d8e661a
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/MethodSorter.java
@@ -0,0 +1,72 @@
+package org.junit.internal;
+
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Comparator;
+
+import org.junit.FixMethodOrder;
+
+public class MethodSorter {
+    /**
+     * DEFAULT sort order
+     */
+    public static final Comparator<Method> DEFAULT = new Comparator<Method>() {
+        public int compare(Method m1, Method m2) {
+            int i1 = m1.getName().hashCode();
+            int i2 = m2.getName().hashCode();
+            if (i1 != i2) {
+                return i1 < i2 ? -1 : 1;
+            }
+            return NAME_ASCENDING.compare(m1, m2);
+        }
+    };
+
+    /**
+     * Method name ascending lexicographic sort order, with {@link Method#toString()} as a tiebreaker
+     */
+    public static final Comparator<Method> NAME_ASCENDING = new Comparator<Method>() {
+        public int compare(Method m1, Method m2) {
+            final int comparison = m1.getName().compareTo(m2.getName());
+            if (comparison != 0) {
+                return comparison;
+            }
+            return m1.toString().compareTo(m2.toString());
+        }
+    };
+
+    /**
+     * Gets declared methods of a class in a predictable order, unless @FixMethodOrder(MethodSorters.JVM) is specified.
+     *
+     * Using the JVM order is unwise since the Java platform does not
+     * specify any particular order, and in fact JDK 7 returns a more or less
+     * random order; well-written test code would not assume any order, but some
+     * does, and a predictable failure is better than a random failure on
+     * certain platforms. By default, uses an unspecified but deterministic order.
+     *
+     * @param clazz a class
+     * @return same as {@link Class#getDeclaredMethods} but sorted
+     * @see <a href="http://bugs.sun.com/view_bug.do?bug_id=7023180">JDK
+     *      (non-)bug #7023180</a>
+     */
+    public static Method[] getDeclaredMethods(Class<?> clazz) {
+        Comparator<Method> comparator = getSorter(clazz.getAnnotation(FixMethodOrder.class));
+
+        Method[] methods = clazz.getDeclaredMethods();
+        if (comparator != null) {
+            Arrays.sort(methods, comparator);
+        }
+
+        return methods;
+    }
+
+    private MethodSorter() {
+    }
+
+    private static Comparator<Method> getSorter(FixMethodOrder fixMethodOrder) {
+        if (fixMethodOrder == null) {
+            return DEFAULT;
+        }
+
+        return fixMethodOrder.value().getComparator();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/RealSystem.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/RealSystem.java
new file mode 100644
index 0000000..e64e1fe
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/RealSystem.java
@@ -0,0 +1,19 @@
+package org.junit.internal;
+
+import java.io.PrintStream;
+
+public class RealSystem implements JUnitSystem {
+
+    /**
+     * Will be removed in the next major release
+     */
+    @Deprecated
+    public void exit(int code) {
+        System.exit(code);
+    }
+
+    public PrintStream out() {
+        return System.out;
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/SerializableMatcherDescription.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/SerializableMatcherDescription.java
new file mode 100644
index 0000000..e036557
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/SerializableMatcherDescription.java
@@ -0,0 +1,47 @@
+package org.junit.internal;
+
+import java.io.Serializable;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.StringDescription;
+
+/**
+ * This class exists solely to provide a serializable description of a matcher to be serialized as a field in
+ * {@link AssumptionViolatedException}. Being a {@link Throwable}, it is required to be {@link Serializable}, but most
+ * implementations of {@link Matcher} are not. This class works around that limitation as
+ * {@link AssumptionViolatedException} only every uses the description of the {@link Matcher}, while still retaining
+ * backwards compatibility with classes compiled against its class signature before 4.14 and/or deserialization of
+ * previously serialized instances.
+ */
+class SerializableMatcherDescription<T> extends BaseMatcher<T> implements Serializable {
+
+    private final String matcherDescription;
+
+    private SerializableMatcherDescription(Matcher<T> matcher) {
+        matcherDescription = StringDescription.asString(matcher);
+    }
+
+    public boolean matches(Object o) {
+        throw new UnsupportedOperationException("This Matcher implementation only captures the description");
+    }
+
+    public void describeTo(Description description) {
+        description.appendText(matcherDescription);
+    }
+
+    /**
+     * Factory method that checks to see if the matcher is already serializable.
+     * @param matcher the matcher to make serializable
+     * @return The provided matcher if it is null or already serializable,
+     * the SerializableMatcherDescription representation of it if it is not.
+     */
+    static <T> Matcher<T> asSerializableMatcher(Matcher<T> matcher) {
+        if (matcher == null || matcher instanceof Serializable) {
+            return matcher;
+        } else {
+            return new SerializableMatcherDescription<T>(matcher);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/SerializableValueDescription.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/SerializableValueDescription.java
new file mode 100644
index 0000000..4d055d7
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/SerializableValueDescription.java
@@ -0,0 +1,38 @@
+package org.junit.internal;
+
+import java.io.Serializable;
+
+/**
+ * This class exists solely to provide a serializable description of a value to be serialized as a field in
+ * {@link AssumptionViolatedException}. Being a {@link Throwable}, it is required to be {@link Serializable}, but a
+ * value of type Object provides no guarantee to be serializable. This class works around that limitation as
+ * {@link AssumptionViolatedException} only every uses the string representation of the value, while still retaining
+ * backwards compatibility with classes compiled against its class signature before 4.14 and/or deserialization of
+ * previously serialized instances.
+ */
+class SerializableValueDescription implements Serializable {
+    private final String value;
+
+    private SerializableValueDescription(Object value) {
+        this.value = String.valueOf(value);
+    }
+
+    /**
+     * Factory method that checks to see if the value is already serializable.
+     * @param value the value to make serializable
+     * @return The provided value if it is null or already serializable,
+     * the SerializableValueDescription representation of it if it is not.
+     */
+    static Object asSerializableValue(Object value) {
+        if (value == null || value instanceof Serializable) {
+            return value;
+        } else {
+            return new SerializableValueDescription(value);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return value;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/TextListener.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/TextListener.java
new file mode 100644
index 0000000..d548aeb
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/TextListener.java
@@ -0,0 +1,101 @@
+package org.junit.internal;
+
+import java.io.PrintStream;
+import java.text.NumberFormat;
+import java.util.List;
+
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+
+public class TextListener extends RunListener {
+
+    private final PrintStream writer;
+
+    public TextListener(JUnitSystem system) {
+        this(system.out());
+    }
+
+    public TextListener(PrintStream writer) {
+        this.writer = writer;
+    }
+
+    @Override
+    public void testRunFinished(Result result) {
+        printHeader(result.getRunTime());
+        printFailures(result);
+        printFooter(result);
+    }
+
+    @Override
+    public void testStarted(Description description) {
+        writer.append('.');
+    }
+
+    @Override
+    public void testFailure(Failure failure) {
+        writer.append('E');
+    }
+
+    @Override
+    public void testIgnored(Description description) {
+        writer.append('I');
+    }
+
+    /*
+      * Internal methods
+      */
+
+    private PrintStream getWriter() {
+        return writer;
+    }
+
+    protected void printHeader(long runTime) {
+        getWriter().println();
+        getWriter().println("Time: " + elapsedTimeAsString(runTime));
+    }
+
+    protected void printFailures(Result result) {
+        List<Failure> failures = result.getFailures();
+        if (failures.isEmpty()) {
+            return;
+        }
+        if (failures.size() == 1) {
+            getWriter().println("There was " + failures.size() + " failure:");
+        } else {
+            getWriter().println("There were " + failures.size() + " failures:");
+        }
+        int i = 1;
+        for (Failure each : failures) {
+            printFailure(each, "" + i++);
+        }
+    }
+
+    protected void printFailure(Failure each, String prefix) {
+        getWriter().println(prefix + ") " + each.getTestHeader());
+        getWriter().print(each.getTrimmedTrace());
+    }
+
+    protected void printFooter(Result result) {
+        if (result.wasSuccessful()) {
+            getWriter().println();
+            getWriter().print("OK");
+            getWriter().println(" (" + result.getRunCount() + " test" + (result.getRunCount() == 1 ? "" : "s") + ")");
+
+        } else {
+            getWriter().println();
+            getWriter().println("FAILURES!!!");
+            getWriter().println("Tests run: " + result.getRunCount() + ",  Failures: " + result.getFailureCount());
+        }
+        getWriter().println();
+    }
+
+    /**
+     * Returns the formatted string of the elapsed time. Duplicated from
+     * BaseTestRunner. Fix it.
+     */
+    protected String elapsedTimeAsString(long runTime) {
+        return NumberFormat.getInstance().format((double) runTime / 1000);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/Throwables.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/Throwables.java
new file mode 100644
index 0000000..3f0f7a3
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/Throwables.java
@@ -0,0 +1,273 @@
+package org.junit.internal;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.lang.reflect.Method;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Miscellaneous functions dealing with {@code Throwable}.
+ *
+ * @author kcooney@google.com (Kevin Cooney)
+ * @since 4.12
+ */
+public final class Throwables {
+
+    private Throwables() {
+    }
+
+    /**
+     * Rethrows the given {@code Throwable}, allowing the caller to
+     * declare that it throws {@code Exception}. This is useful when
+     * your callers have nothing reasonable they can do when a
+     * {@code Throwable} is thrown. This is declared to return {@code Exception}
+     * so it can be used in a {@code throw} clause:
+     * <pre>
+     * try {
+     *   doSomething();
+     * } catch (Throwable e} {
+     *   throw Throwables.rethrowAsException(e);
+     * }
+     * doSomethingLater();
+     * </pre>
+     *
+     * @param e exception to rethrow
+     * @return does not return anything
+     * @since 4.12
+     */
+    public static Exception rethrowAsException(Throwable e) throws Exception {
+        Throwables.<Exception>rethrow(e);
+        return null; // we never get here
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T extends Throwable> void rethrow(Throwable e) throws T {
+        throw (T) e;
+    }
+
+    /**
+     * Returns the stacktrace of the given Throwable as a String.
+     *
+     * @since 4.13
+     */
+    public static String getStacktrace(Throwable exception) {
+        StringWriter stringWriter = new StringWriter();
+        PrintWriter writer = new PrintWriter(stringWriter);
+        exception.printStackTrace(writer);
+        return stringWriter.toString();
+    }
+
+    /**
+     * Gets a trimmed version of the stack trace of the given exception. Stack trace
+     * elements that are below the test method are filtered out.
+     *
+     * @return a trimmed stack trace, or the original trace if trimming wasn't possible
+     */
+    public static String getTrimmedStackTrace(Throwable exception) {
+        List<String> trimmedStackTraceLines = getTrimmedStackTraceLines(exception);
+        if (trimmedStackTraceLines.isEmpty()) {
+            return getFullStackTrace(exception);
+        }
+
+        StringBuilder result = new StringBuilder(exception.toString());
+        appendStackTraceLines(trimmedStackTraceLines, result);
+        appendStackTraceLines(getCauseStackTraceLines(exception), result);
+        return result.toString();
+    }
+
+    private static List<String> getTrimmedStackTraceLines(Throwable exception) {
+        List<StackTraceElement> stackTraceElements = Arrays.asList(exception.getStackTrace());
+        int linesToInclude = stackTraceElements.size();
+
+        State state = State.PROCESSING_OTHER_CODE;
+        for (StackTraceElement stackTraceElement : asReversedList(stackTraceElements)) {
+            state = state.processStackTraceElement(stackTraceElement);
+            if (state == State.DONE) {
+                List<String> trimmedLines = new ArrayList<String>(linesToInclude + 2);
+                trimmedLines.add("");
+                for (StackTraceElement each : stackTraceElements.subList(0, linesToInclude)) {
+                    trimmedLines.add("\tat " + each);
+                }
+                if (exception.getCause() != null) {
+                    trimmedLines.add("\t... " + (stackTraceElements.size() - trimmedLines.size()) + " trimmed");
+                }
+                return trimmedLines;
+            }
+            linesToInclude--;
+        }
+        return Collections.emptyList();
+    }
+
+    private static final Method getSuppressed = initGetSuppressed();
+
+    private static Method initGetSuppressed() {
+        try {
+            return Throwable.class.getMethod("getSuppressed");
+        } catch (Throwable e) {
+            return null;
+        }
+    }
+
+    private static boolean hasSuppressed(Throwable exception) {
+        if (getSuppressed == null) {
+            return false;
+        }
+        try {
+            Throwable[] suppressed = (Throwable[]) getSuppressed.invoke(exception);
+            return suppressed.length != 0;
+        } catch (Throwable e) {
+            return false;
+        }
+    }
+
+    private static List<String> getCauseStackTraceLines(Throwable exception) {
+        if (exception.getCause() != null || hasSuppressed(exception)) {
+            String fullTrace = getFullStackTrace(exception);
+            BufferedReader reader = new BufferedReader(
+                    new StringReader(fullTrace.substring(exception.toString().length())));
+            List<String> causedByLines = new ArrayList<String>();
+    
+            try {
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    if (line.startsWith("Caused by: ") || line.trim().startsWith("Suppressed: ")) {
+                        causedByLines.add(line);
+                        while ((line = reader.readLine()) != null) {
+                            causedByLines.add(line);
+                        }
+                        return causedByLines;
+                    }
+                }
+            } catch (IOException e) {
+                // We should never get here, because we are reading from a StringReader
+            }
+        }
+
+        return Collections.emptyList();
+    }
+
+    private static String getFullStackTrace(Throwable exception) {
+        StringWriter stringWriter = new StringWriter();
+        PrintWriter writer = new PrintWriter(stringWriter);
+        exception.printStackTrace(writer);
+        return stringWriter.toString();
+    }
+
+    private static void appendStackTraceLines(
+            List<String> stackTraceLines, StringBuilder destBuilder) {
+        for (String stackTraceLine : stackTraceLines) {
+            destBuilder.append(String.format("%s%n", stackTraceLine));
+        }
+    }
+
+    private static <T> List<T> asReversedList(final List<T> list) {
+        return new AbstractList<T>() {
+
+            @Override
+            public T get(int index) {
+                return list.get(list.size() - index - 1);
+            }
+
+            @Override
+            public int size() {
+                return list.size();
+            }
+        };
+    }
+
+    private enum State {
+        PROCESSING_OTHER_CODE {
+            @Override public State processLine(String methodName) {
+                if (isTestFrameworkMethod(methodName)) {
+                    return PROCESSING_TEST_FRAMEWORK_CODE;
+                }
+                return this;
+            }
+        },
+        PROCESSING_TEST_FRAMEWORK_CODE {
+            @Override public State processLine(String methodName) {
+                if (isReflectionMethod(methodName)) {
+                    return PROCESSING_REFLECTION_CODE;
+                } else if (isTestFrameworkMethod(methodName)) {
+                    return this;
+                }
+                return PROCESSING_OTHER_CODE;
+            } 
+        },
+        PROCESSING_REFLECTION_CODE {
+            @Override public State processLine(String methodName) {
+                if (isReflectionMethod(methodName)) {
+                    return this;
+                } else if (isTestFrameworkMethod(methodName)) {
+                    // This is here to handle TestCase.runBare() calling TestCase.runTest().
+                    return PROCESSING_TEST_FRAMEWORK_CODE;
+                }
+                return DONE;
+            } 
+        },
+        DONE {
+            @Override public State processLine(String methodName) {
+                return this;
+            } 
+        };
+
+        /** Processes a stack trace element method name, possibly moving to a new state. */
+        protected abstract State processLine(String methodName);
+        
+        /** Processes a stack trace element, possibly moving to a new state. */
+        public final State processStackTraceElement(StackTraceElement element) {
+            return processLine(element.getClassName() + "." + element.getMethodName() + "()");
+        }
+    }
+
+    private static final String[] TEST_FRAMEWORK_METHOD_NAME_PREFIXES = {
+        "org.junit.runner.",
+        "org.junit.runners.",
+        "org.junit.experimental.runners.",
+        "org.junit.internal.",
+        "junit.extensions",
+        "junit.framework",
+        "junit.runner",
+        "junit.textui",
+    };
+
+    private static final String[] TEST_FRAMEWORK_TEST_METHOD_NAME_PREFIXES = {
+        "org.junit.internal.StackTracesTest",
+    };
+
+    private static boolean isTestFrameworkMethod(String methodName) {
+        return isMatchingMethod(methodName, TEST_FRAMEWORK_METHOD_NAME_PREFIXES) &&
+                !isMatchingMethod(methodName, TEST_FRAMEWORK_TEST_METHOD_NAME_PREFIXES);
+    }
+    
+    private static final String[] REFLECTION_METHOD_NAME_PREFIXES = {
+        "sun.reflect.",
+        "java.lang.reflect.",
+        "jdk.internal.reflect.",
+        "org.junit.rules.RunRules.<init>(",
+        "org.junit.rules.RunRules.applyAll(", // calls TestRules
+        "org.junit.runners.RuleContainer.apply(", // calls MethodRules & TestRules
+        "junit.framework.TestCase.runBare(", // runBare() directly calls setUp() and tearDown()
+   };
+    
+    private static boolean isReflectionMethod(String methodName) {
+        return isMatchingMethod(methodName, REFLECTION_METHOD_NAME_PREFIXES);
+    }
+
+    private static boolean isMatchingMethod(String methodName, String[] methodNamePrefixes) {
+        for (String methodNamePrefix : methodNamePrefixes) {
+            if (methodName.startsWith(methodNamePrefix)) {
+                return true;
+            }
+        }
+        
+        return false;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/AllDefaultPossibilitiesBuilder.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/AllDefaultPossibilitiesBuilder.java
new file mode 100644
index 0000000..8704a54
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/AllDefaultPossibilitiesBuilder.java
@@ -0,0 +1,67 @@
+package org.junit.internal.builders;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.runner.Runner;
+import org.junit.runners.model.RunnerBuilder;
+
+public class AllDefaultPossibilitiesBuilder extends RunnerBuilder {
+    private final boolean canUseSuiteMethod;
+
+    /**
+     * @since 4.13
+     */
+    public AllDefaultPossibilitiesBuilder() {
+        canUseSuiteMethod = true;
+    }
+
+    /**
+     * @deprecated used {@link #AllDefaultPossibilitiesBuilder()}.
+     */
+    @Deprecated
+    public AllDefaultPossibilitiesBuilder(boolean canUseSuiteMethod) {
+        this.canUseSuiteMethod = canUseSuiteMethod;
+    }
+
+    @Override
+    public Runner runnerForClass(Class<?> testClass) throws Throwable {
+        List<RunnerBuilder> builders = Arrays.asList(
+                ignoredBuilder(),
+                annotatedBuilder(),
+                suiteMethodBuilder(),
+                junit3Builder(),
+                junit4Builder());
+
+        for (RunnerBuilder each : builders) {
+            Runner runner = each.safeRunnerForClass(testClass);
+            if (runner != null) {
+                return runner;
+            }
+        }
+        return null;
+    }
+
+    protected JUnit4Builder junit4Builder() {
+        return new JUnit4Builder();
+    }
+
+    protected JUnit3Builder junit3Builder() {
+        return new JUnit3Builder();
+    }
+
+    protected AnnotatedBuilder annotatedBuilder() {
+        return new AnnotatedBuilder(this);
+    }
+
+    protected IgnoredBuilder ignoredBuilder() {
+        return new IgnoredBuilder();
+    }
+
+    protected RunnerBuilder suiteMethodBuilder() {
+        if (canUseSuiteMethod) {
+            return new SuiteMethodBuilder();
+        }
+        return new NullBuilder();
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/AnnotatedBuilder.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/AnnotatedBuilder.java
new file mode 100644
index 0000000..04d7a68
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/AnnotatedBuilder.java
@@ -0,0 +1,116 @@
+package org.junit.internal.builders;
+
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.RunnerBuilder;
+
+import java.lang.reflect.Modifier;
+
+
+/**
+ * The {@code AnnotatedBuilder} is a strategy for constructing runners for test class that have been annotated with the
+ * {@code @RunWith} annotation. All tests within this class will be executed using the runner that was specified within
+ * the annotation.
+ * <p>
+ * If a runner supports inner member classes, the member classes will inherit the runner from the enclosing class, e.g.:
+ * <pre>
+ * &#064;RunWith(MyRunner.class)
+ * public class MyTest {
+ *     // some tests might go here
+ *
+ *     public class MyMemberClass {
+ *         &#064;Test
+ *         public void thisTestRunsWith_MyRunner() {
+ *             // some test logic
+ *         }
+ *
+ *         // some more tests might go here
+ *     }
+ *
+ *     &#064;RunWith(AnotherRunner.class)
+ *     public class AnotherMemberClass {
+ *         // some tests might go here
+ *
+ *         public class DeepInnerClass {
+ *             &#064;Test
+ *             public void thisTestRunsWith_AnotherRunner() {
+ *                 // some test logic
+ *             }
+ *         }
+ *
+ *         public class DeepInheritedClass extends SuperTest {
+ *             &#064;Test
+ *             public void thisTestRunsWith_SuperRunner() {
+ *                 // some test logic
+ *             }
+ *         }
+ *     }
+ * }
+ *
+ * &#064;RunWith(SuperRunner.class)
+ * public class SuperTest {
+ *     // some tests might go here
+ * }
+ * </pre>
+ * The key points to note here are:
+ * <ul>
+ *     <li>If there is no RunWith annotation, no runner will be created.</li>
+ *     <li>The resolve step is inside-out, e.g. the closest RunWith annotation wins</li>
+ *     <li>RunWith annotations are inherited and work as if the class was annotated itself.</li>
+ *     <li>The default JUnit runner does not support inner member classes,
+ *         so this is only valid for custom runners that support inner member classes.</li>
+ *     <li>Custom runners with support for inner classes may or may not support RunWith annotations for member
+ *         classes. Please refer to the custom runner documentation.</li>
+ * </ul>
+ *
+ * @see org.junit.runners.model.RunnerBuilder
+ * @see org.junit.runner.RunWith
+ * @since 4.0
+ */
+public class AnnotatedBuilder extends RunnerBuilder {
+    private static final String CONSTRUCTOR_ERROR_FORMAT = "Custom runner class %s should have a public constructor with signature %s(Class testClass)";
+
+    private final RunnerBuilder suiteBuilder;
+
+    public AnnotatedBuilder(RunnerBuilder suiteBuilder) {
+        this.suiteBuilder = suiteBuilder;
+    }
+
+    @Override
+    public Runner runnerForClass(Class<?> testClass) throws Exception {
+        for (Class<?> currentTestClass = testClass; currentTestClass != null;
+             currentTestClass = getEnclosingClassForNonStaticMemberClass(currentTestClass)) {
+            RunWith annotation = currentTestClass.getAnnotation(RunWith.class);
+            if (annotation != null) {
+                return buildRunner(annotation.value(), testClass);
+            }
+        }
+
+        return null;
+    }
+
+    private Class<?> getEnclosingClassForNonStaticMemberClass(Class<?> currentTestClass) {
+        if (currentTestClass.isMemberClass() && !Modifier.isStatic(currentTestClass.getModifiers())) {
+            return currentTestClass.getEnclosingClass();
+        } else {
+            return null;
+        }
+    }
+
+    public Runner buildRunner(Class<? extends Runner> runnerClass,
+            Class<?> testClass) throws Exception {
+        try {
+            return runnerClass.getConstructor(Class.class).newInstance(testClass);
+        } catch (NoSuchMethodException e) {
+            try {
+                return runnerClass.getConstructor(Class.class,
+                        RunnerBuilder.class).newInstance(testClass, suiteBuilder);
+            } catch (NoSuchMethodException e2) {
+                String simpleName = runnerClass.getSimpleName();
+                throw new InitializationError(String.format(
+                        CONSTRUCTOR_ERROR_FORMAT, simpleName, simpleName));
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/IgnoredBuilder.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/IgnoredBuilder.java
new file mode 100644
index 0000000..71940c8
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/IgnoredBuilder.java
@@ -0,0 +1,15 @@
+package org.junit.internal.builders;
+
+import org.junit.Ignore;
+import org.junit.runner.Runner;
+import org.junit.runners.model.RunnerBuilder;
+
+public class IgnoredBuilder extends RunnerBuilder {
+    @Override
+    public Runner runnerForClass(Class<?> testClass) {
+        if (testClass.getAnnotation(Ignore.class) != null) {
+            return new IgnoredClassRunner(testClass);
+        }
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/IgnoredClassRunner.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/IgnoredClassRunner.java
new file mode 100644
index 0000000..7c8926b
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/IgnoredClassRunner.java
@@ -0,0 +1,23 @@
+package org.junit.internal.builders;
+
+import org.junit.runner.Description;
+import org.junit.runner.Runner;
+import org.junit.runner.notification.RunNotifier;
+
+public class IgnoredClassRunner extends Runner {
+    private final Class<?> clazz;
+
+    public IgnoredClassRunner(Class<?> testClass) {
+        clazz = testClass;
+    }
+
+    @Override
+    public void run(RunNotifier notifier) {
+        notifier.fireTestIgnored(getDescription());
+    }
+
+    @Override
+    public Description getDescription() {
+        return Description.createSuiteDescription(clazz);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/JUnit3Builder.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/JUnit3Builder.java
new file mode 100644
index 0000000..8b6b371
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/JUnit3Builder.java
@@ -0,0 +1,19 @@
+package org.junit.internal.builders;
+
+import org.junit.internal.runners.JUnit38ClassRunner;
+import org.junit.runner.Runner;
+import org.junit.runners.model.RunnerBuilder;
+
+public class JUnit3Builder extends RunnerBuilder {
+    @Override
+    public Runner runnerForClass(Class<?> testClass) throws Throwable {
+        if (isPre4Test(testClass)) {
+            return new JUnit38ClassRunner(testClass);
+        }
+        return null;
+    }
+
+    boolean isPre4Test(Class<?> testClass) {
+        return junit.framework.TestCase.class.isAssignableFrom(testClass);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/JUnit4Builder.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/JUnit4Builder.java
new file mode 100644
index 0000000..7959e75
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/JUnit4Builder.java
@@ -0,0 +1,12 @@
+package org.junit.internal.builders;
+
+import org.junit.runner.Runner;
+import org.junit.runners.JUnit4;
+import org.junit.runners.model.RunnerBuilder;
+
+public class JUnit4Builder extends RunnerBuilder {
+    @Override
+    public Runner runnerForClass(Class<?> testClass) throws Throwable {
+        return new JUnit4(testClass);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/NullBuilder.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/NullBuilder.java
new file mode 100644
index 0000000..c8d306e
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/NullBuilder.java
@@ -0,0 +1,11 @@
+package org.junit.internal.builders;
+
+import org.junit.runner.Runner;
+import org.junit.runners.model.RunnerBuilder;
+
+public class NullBuilder extends RunnerBuilder {
+    @Override
+    public Runner runnerForClass(Class<?> each) throws Throwable {
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/SuiteMethodBuilder.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/SuiteMethodBuilder.java
new file mode 100644
index 0000000..953e6cf
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/builders/SuiteMethodBuilder.java
@@ -0,0 +1,24 @@
+package org.junit.internal.builders;
+
+import org.junit.internal.runners.SuiteMethod;
+import org.junit.runner.Runner;
+import org.junit.runners.model.RunnerBuilder;
+
+public class SuiteMethodBuilder extends RunnerBuilder {
+    @Override
+    public Runner runnerForClass(Class<?> each) throws Throwable {
+        if (hasSuiteMethod(each)) {
+            return new SuiteMethod(each);
+        }
+        return null;
+    }
+
+    public boolean hasSuiteMethod(Class<?> testClass) {
+        try {
+            testClass.getMethod("suite");
+        } catch (NoSuchMethodException e) {
+            return false;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/management/FakeRuntimeMXBean.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/FakeRuntimeMXBean.java
new file mode 100644
index 0000000..477b150
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/FakeRuntimeMXBean.java
@@ -0,0 +1,21 @@
+package org.junit.internal.management;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * No-op implementation of RuntimeMXBean when the platform doesn't provide it.
+ */
+class FakeRuntimeMXBean implements RuntimeMXBean {
+
+  /**
+   * {@inheritDoc}
+   *
+   * <p>Always returns an empty list.
+   */
+  public List<String> getInputArguments() {
+    return Collections.emptyList();
+  }
+
+}
+
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/management/FakeThreadMXBean.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/FakeThreadMXBean.java
new file mode 100644
index 0000000..893f2e3
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/FakeThreadMXBean.java
@@ -0,0 +1,27 @@
+package org.junit.internal.management;
+
+/**
+ * No-op implementation of ThreadMXBean when the platform doesn't provide it.
+ */
+final class FakeThreadMXBean implements ThreadMXBean {
+
+  /**
+   * {@inheritDoc}
+   *
+   * <p>Always throws an {@link UnsupportedOperationException}
+   */
+  public long getThreadCpuTime(long id) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * {@inheritDoc}
+   *
+   * <p>Always returns false.
+   */
+  public boolean isThreadCpuTimeSupported() {
+    return false;
+  }
+
+}
+
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ManagementFactory.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ManagementFactory.java
new file mode 100644
index 0000000..5be1447
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ManagementFactory.java
@@ -0,0 +1,77 @@
+package org.junit.internal.management;
+
+import org.junit.internal.Classes;
+
+import java.lang.reflect.InvocationTargetException;
+
+/**
+ * Reflective wrapper around {@link java.lang.management.ManagementFactory}
+ */
+public class ManagementFactory {
+  private static final class FactoryHolder {
+    private static final Class<?> MANAGEMENT_FACTORY_CLASS;
+
+    static {
+      Class<?> managementFactoryClass = null;
+      try {
+        managementFactoryClass = Classes.getClass("java.lang.management.ManagementFactory");
+      } catch (ClassNotFoundException e) {
+        // do nothing, managementFactoryClass will be none on failure
+      }
+      MANAGEMENT_FACTORY_CLASS = managementFactoryClass;
+    }
+
+    static Object getBeanObject(String methodName) {
+      if (MANAGEMENT_FACTORY_CLASS != null) {
+        try {
+          return MANAGEMENT_FACTORY_CLASS.getMethod(methodName).invoke(null);
+        } catch (IllegalAccessException e) {
+          // fallthrough
+        } catch (IllegalArgumentException e) {
+          // fallthrough
+        } catch (InvocationTargetException e) {
+          // fallthrough
+        } catch (NoSuchMethodException e) {
+          // fallthrough
+        } catch (SecurityException e) {
+          // fallthrough
+        }
+      }
+      return null;
+    }
+  }
+
+  private static final class RuntimeHolder {
+    private static final RuntimeMXBean RUNTIME_MX_BEAN =
+        getBean(FactoryHolder.getBeanObject("getRuntimeMXBean"));
+
+    private static final RuntimeMXBean getBean(Object runtimeMxBean) {
+      return runtimeMxBean != null
+          ? new ReflectiveRuntimeMXBean(runtimeMxBean) : new FakeRuntimeMXBean();
+    }
+  }
+
+  private static final class ThreadHolder {
+    private static final ThreadMXBean THREAD_MX_BEAN =
+        getBean(FactoryHolder.getBeanObject("getThreadMXBean"));
+
+    private static final ThreadMXBean getBean(Object threadMxBean) {
+      return threadMxBean != null
+          ? new ReflectiveThreadMXBean(threadMxBean) : new FakeThreadMXBean();
+    }
+  }
+
+  /**
+   * @see java.lang.management.ManagementFactory#getRuntimeMXBean()
+   */
+  public static RuntimeMXBean getRuntimeMXBean() {
+    return RuntimeHolder.RUNTIME_MX_BEAN;
+  }
+
+  /**
+   * @see java.lang.management.ManagementFactory#getThreadMXBean()
+   */
+  public static ThreadMXBean getThreadMXBean() {
+    return ThreadHolder.THREAD_MX_BEAN;
+  }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ReflectiveRuntimeMXBean.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ReflectiveRuntimeMXBean.java
new file mode 100644
index 0000000..289587a
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ReflectiveRuntimeMXBean.java
@@ -0,0 +1,61 @@
+package org.junit.internal.management;
+
+import org.junit.internal.Classes;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Implementation of {@link RuntimeMXBean} using the JVM reflectively.
+ */
+final class ReflectiveRuntimeMXBean implements RuntimeMXBean {
+  private final Object runtimeMxBean;
+
+  private static final class Holder {
+    private static final Method getInputArgumentsMethod;
+    static {
+      Method inputArguments = null;
+      try {
+        Class<?> threadMXBeanClass = Classes.getClass("java.lang.management.RuntimeMXBean");
+        inputArguments = threadMXBeanClass.getMethod("getInputArguments");
+      } catch (ClassNotFoundException e) {
+        // do nothing, input arguments will be null on failure
+      } catch (NoSuchMethodException e) {
+        // do nothing, input arguments will be null on failure
+      } catch (SecurityException e) {
+        // do nothing, input arguments will be null on failure
+      }
+      getInputArgumentsMethod = inputArguments;
+    }
+  }
+
+  ReflectiveRuntimeMXBean(Object runtimeMxBean) {
+    super();
+    this.runtimeMxBean = runtimeMxBean;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  @SuppressWarnings("unchecked")
+  public List<String> getInputArguments() {
+    if (Holder.getInputArgumentsMethod != null) {
+      try {
+        return (List<String>) Holder.getInputArgumentsMethod.invoke(runtimeMxBean);
+      } catch (ClassCastException e) { // no multi-catch with source level 6
+        // fallthrough
+      } catch (IllegalAccessException e) {
+        // fallthrough
+      } catch (IllegalArgumentException e) {
+        // fallthrough
+      } catch (InvocationTargetException e) {
+        // fallthrough
+      }
+    }
+    return Collections.emptyList();
+  }
+
+}
+
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ReflectiveThreadMXBean.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ReflectiveThreadMXBean.java
new file mode 100644
index 0000000..bc741be
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ReflectiveThreadMXBean.java
@@ -0,0 +1,92 @@
+package org.junit.internal.management;
+
+import org.junit.internal.Classes;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * Implementation of {@link ThreadMXBean} using the JVM reflectively.
+ */
+final class ReflectiveThreadMXBean implements ThreadMXBean {
+  private final Object threadMxBean;
+
+
+  private static final class Holder {
+    static final Method getThreadCpuTimeMethod;
+    static final Method isThreadCpuTimeSupportedMethod;
+
+    private static final String FAILURE_MESSAGE = "Unable to access ThreadMXBean";
+
+    static {
+      Method threadCpuTime = null;
+      Method threadCpuTimeSupported = null;
+      try {
+        Class<?> threadMXBeanClass = Classes.getClass("java.lang.management.ThreadMXBean");
+        threadCpuTime = threadMXBeanClass.getMethod("getThreadCpuTime", long.class);
+        threadCpuTimeSupported = threadMXBeanClass.getMethod("isThreadCpuTimeSupported");
+      } catch (ClassNotFoundException e) {
+        // do nothing, the methods will be null on failure
+      } catch (NoSuchMethodException e) {
+        // do nothing, the methods will be null on failure
+      } catch (SecurityException e) {
+        // do nothing, the methods will be null on failure
+      }
+      getThreadCpuTimeMethod = threadCpuTime;
+      isThreadCpuTimeSupportedMethod = threadCpuTimeSupported;
+    }
+  }
+
+  ReflectiveThreadMXBean(Object threadMxBean) {
+    super();
+    this.threadMxBean = threadMxBean;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public long getThreadCpuTime(long id) {
+    if (Holder.getThreadCpuTimeMethod != null) {
+      Exception error = null;
+      try {
+        return (Long) Holder.getThreadCpuTimeMethod.invoke(threadMxBean, id);
+      } catch (ClassCastException e) {
+        error = e;
+        // fallthrough
+      } catch (IllegalAccessException e) {
+        error = e;
+        // fallthrough
+      } catch (IllegalArgumentException e) {
+        error = e;
+        // fallthrough
+      } catch (InvocationTargetException e) {
+        error = e;
+        // fallthrough
+      }
+      throw new UnsupportedOperationException(Holder.FAILURE_MESSAGE, error);
+    }
+    throw new UnsupportedOperationException(Holder.FAILURE_MESSAGE);
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public boolean isThreadCpuTimeSupported() {
+    if (Holder.isThreadCpuTimeSupportedMethod != null) {
+      try {
+        return (Boolean) Holder.isThreadCpuTimeSupportedMethod.invoke(threadMxBean);
+      } catch (ClassCastException e) {
+        // fallthrough
+      } catch (IllegalAccessException e) {
+        // fallthrough
+      } catch (IllegalArgumentException e) {
+        // fallthrough
+      } catch (InvocationTargetException e) {
+        // fallthrough
+      }
+    }
+    return false;
+  }
+
+}
+
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/management/RuntimeMXBean.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/RuntimeMXBean.java
new file mode 100644
index 0000000..84f8861
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/RuntimeMXBean.java
@@ -0,0 +1,14 @@
+package org.junit.internal.management;
+
+import java.util.List;
+
+/**
+ * Wrapper for {@link java.lang.management.RuntimeMXBean}.
+ */
+public interface RuntimeMXBean {
+
+  /**
+   * @see java.lang.management.RuntimeMXBean#getInputArguments()
+   */
+  List<String> getInputArguments();
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ThreadMXBean.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ThreadMXBean.java
new file mode 100644
index 0000000..f9225c9
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/management/ThreadMXBean.java
@@ -0,0 +1,17 @@
+package org.junit.internal.management;
+
+/**
+ * Wrapper for {@link java.lang.management.ThreadMXBean}.
+ */
+public interface ThreadMXBean {
+  /**
+   * @see java.lang.management.ThreadMXBean#getThreadCpuTime(long)
+   */
+  long getThreadCpuTime(long id);
+
+  /**
+   * @see java.lang.management.ThreadMXBean#isThreadCpuTimeSupported()
+   */
+  boolean isThreadCpuTimeSupported();
+}
+
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/StacktracePrintingMatcher.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/StacktracePrintingMatcher.java
new file mode 100644
index 0000000..93a6827
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/StacktracePrintingMatcher.java
@@ -0,0 +1,53 @@
+package org.junit.internal.matchers;
+
+import org.hamcrest.Description;
+import org.hamcrest.Factory;
+import org.hamcrest.Matcher;
+
+import org.junit.internal.Throwables;
+
+/**
+ * A matcher that delegates to throwableMatcher and in addition appends the
+ * stacktrace of the actual Throwable in case of a mismatch.
+ */
+public class StacktracePrintingMatcher<T extends Throwable> extends
+        org.hamcrest.TypeSafeMatcher<T> {
+
+    private final Matcher<T> throwableMatcher;
+
+    public StacktracePrintingMatcher(Matcher<T> throwableMatcher) {
+        this.throwableMatcher = throwableMatcher;
+    }
+
+    public void describeTo(Description description) {
+        throwableMatcher.describeTo(description);
+    }
+
+    @Override
+    protected boolean matchesSafely(T item) {
+        return throwableMatcher.matches(item);
+    }
+
+    @Override
+    protected void describeMismatchSafely(T item, Description description) {
+        throwableMatcher.describeMismatch(item, description);
+        description.appendText("\nStacktrace was: ");
+        description.appendText(readStacktrace(item));
+    }
+
+    private String readStacktrace(Throwable throwable) {
+        return Throwables.getStacktrace(throwable);
+    }
+
+    @Factory
+    public static <T extends Throwable> Matcher<T> isThrowable(
+            Matcher<T> throwableMatcher) {
+        return new StacktracePrintingMatcher<T>(throwableMatcher);
+    }
+
+    @Factory
+    public static <T extends Exception> Matcher<T> isException(
+            Matcher<T> exceptionMatcher) {
+        return new StacktracePrintingMatcher<T>(exceptionMatcher);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/ThrowableCauseMatcher.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/ThrowableCauseMatcher.java
new file mode 100644
index 0000000..6e2ff5e
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/ThrowableCauseMatcher.java
@@ -0,0 +1,50 @@
+package org.junit.internal.matchers;
+
+import org.hamcrest.Description;
+import org.hamcrest.Factory;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+
+/**
+ * A matcher that applies a delegate matcher to the cause of the current Throwable, returning the result of that
+ * match.
+ *
+ * @param <T> the type of the throwable being matched
+ */
+public class ThrowableCauseMatcher<T extends Throwable> extends
+        TypeSafeMatcher<T> {
+
+    private final Matcher<?> causeMatcher;
+
+    public ThrowableCauseMatcher(Matcher<?> causeMatcher) {
+        this.causeMatcher = causeMatcher;
+    }
+
+    public void describeTo(Description description) {
+        description.appendText("exception with cause ");
+        description.appendDescriptionOf(causeMatcher);
+    }
+
+    @Override
+    protected boolean matchesSafely(T item) {
+        return causeMatcher.matches(item.getCause());
+    }
+
+    @Override
+    protected void describeMismatchSafely(T item, Description description) {
+        description.appendText("cause ");
+        causeMatcher.describeMismatch(item.getCause(), description);
+    }
+
+    /**
+     * Returns a matcher that verifies that the outer exception has a cause for which the supplied matcher
+     * evaluates to true.
+     *
+     * @param matcher to apply to the cause of the outer exception
+     * @param <T> type of the outer exception
+     */
+    @Factory
+    public static <T extends Throwable> Matcher<T> hasCause(final Matcher<?> matcher) {
+        return new ThrowableCauseMatcher<T>(matcher);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/ThrowableMessageMatcher.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/ThrowableMessageMatcher.java
new file mode 100644
index 0000000..74386a8
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/ThrowableMessageMatcher.java
@@ -0,0 +1,37 @@
+package org.junit.internal.matchers;
+
+import org.hamcrest.Description;
+import org.hamcrest.Factory;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+
+public class ThrowableMessageMatcher<T extends Throwable> extends
+        TypeSafeMatcher<T> {
+
+    private final Matcher<String> matcher;
+
+    public ThrowableMessageMatcher(Matcher<String> matcher) {
+        this.matcher = matcher;
+    }
+
+    public void describeTo(Description description) {
+        description.appendText("exception with message ");
+        description.appendDescriptionOf(matcher);
+    }
+
+    @Override
+    protected boolean matchesSafely(T item) {
+        return matcher.matches(item.getMessage());
+    }
+
+    @Override
+    protected void describeMismatchSafely(T item, Description description) {
+        description.appendText("message ");
+        matcher.describeMismatch(item.getMessage(), description);
+    }
+
+    @Factory
+    public static <T extends Throwable> Matcher<T> hasMessage(final Matcher<String> matcher) {
+        return new ThrowableMessageMatcher<T>(matcher);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/TypeSafeMatcher.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/TypeSafeMatcher.java
new file mode 100644
index 0000000..fb25982
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/matchers/TypeSafeMatcher.java
@@ -0,0 +1,63 @@
+package org.junit.internal.matchers;
+
+import java.lang.reflect.Method;
+
+import org.hamcrest.BaseMatcher;
+import org.junit.internal.MethodSorter;
+
+/**
+ * Convenient base class for Matchers that require a non-null value of a specific type.
+ * This simply implements the null check, checks the type and then casts.
+ *
+ * @author Joe Walnes
+ * @deprecated Please use {@link org.hamcrest.TypeSafeMatcher}.
+ */
+@Deprecated
+public abstract class TypeSafeMatcher<T> extends BaseMatcher<T> {
+
+    private Class<?> expectedType;
+
+    /**
+     * Subclasses should implement this. The item will already have been checked for
+     * the specific type and will never be null.
+     */
+    public abstract boolean matchesSafely(T item);
+
+    protected TypeSafeMatcher() {
+        expectedType = findExpectedType(getClass());
+    }
+
+    private static Class<?> findExpectedType(Class<?> fromClass) {
+        for (Class<?> c = fromClass; c != Object.class; c = c.getSuperclass()) {
+            for (Method method : MethodSorter.getDeclaredMethods(c)) {
+                if (isMatchesSafelyMethod(method)) {
+                    return method.getParameterTypes()[0];
+                }
+            }
+        }
+
+        throw new Error("Cannot determine correct type for matchesSafely() method.");
+    }
+
+    private static boolean isMatchesSafelyMethod(Method method) {
+        return "matchesSafely".equals(method.getName())
+                && method.getParameterTypes().length == 1
+                && !method.isSynthetic();
+    }
+
+    protected TypeSafeMatcher(Class<T> expectedType) {
+        this.expectedType = expectedType;
+    }
+
+    /**
+     * Method made final to prevent accidental override.
+     * If you need to override this, there's no point on extending TypeSafeMatcher.
+     * Instead, extend the {@link BaseMatcher}.
+     */
+    @SuppressWarnings({"unchecked"})
+    public final boolean matches(Object item) {
+        return item != null
+                && expectedType.isInstance(item)
+                && matchesSafely((T) item);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/ClassRequest.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/ClassRequest.java
new file mode 100644
index 0000000..d60e360
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/ClassRequest.java
@@ -0,0 +1,54 @@
+package org.junit.internal.requests;
+
+import org.junit.internal.builders.AllDefaultPossibilitiesBuilder;
+import org.junit.internal.builders.SuiteMethodBuilder;
+import org.junit.runner.Runner;
+import org.junit.runners.model.RunnerBuilder;
+
+public class ClassRequest extends MemoizingRequest {
+    /*
+     * We have to use the f prefix, because IntelliJ's JUnit4IdeaTestRunner uses
+     * reflection to access this field. See
+     * https://github.com/junit-team/junit4/issues/960
+     */
+    private final Class<?> fTestClass;
+    private final boolean canUseSuiteMethod;
+
+    public ClassRequest(Class<?> testClass, boolean canUseSuiteMethod) {
+        this.fTestClass = testClass;
+        this.canUseSuiteMethod = canUseSuiteMethod;
+    }
+
+    public ClassRequest(Class<?> testClass) {
+        this(testClass, true);
+    }
+
+    @Override
+    protected Runner createRunner() {
+        return new CustomAllDefaultPossibilitiesBuilder().safeRunnerForClass(fTestClass);
+    }
+
+    private class CustomAllDefaultPossibilitiesBuilder extends AllDefaultPossibilitiesBuilder {
+
+        @Override
+        protected RunnerBuilder suiteMethodBuilder() {
+            return new CustomSuiteMethodBuilder();
+        }
+    }
+
+    /*
+     * Customization of {@link SuiteMethodBuilder} that prevents use of the
+     * suite method when creating a runner for fTestClass when canUseSuiteMethod
+     * is false.
+     */
+    private class CustomSuiteMethodBuilder extends SuiteMethodBuilder {
+
+        @Override
+        public Runner runnerForClass(Class<?> testClass) throws Throwable {
+            if (testClass == fTestClass && !canUseSuiteMethod) {
+                return null;
+            }
+            return super.runnerForClass(testClass);
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/FilterRequest.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/FilterRequest.java
new file mode 100644
index 0000000..5f00399
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/FilterRequest.java
@@ -0,0 +1,45 @@
+package org.junit.internal.requests;
+
+import org.junit.internal.runners.ErrorReportingRunner;
+import org.junit.runner.Request;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.NoTestsRemainException;
+
+/**
+ * A filtered {@link Request}.
+ */
+public final class FilterRequest extends Request {
+    private final Request request;
+    /*
+     * We have to use the f prefix, because IntelliJ's JUnit4IdeaTestRunner uses
+     * reflection to access this field. See
+     * https://github.com/junit-team/junit4/issues/960
+     */
+    private final Filter fFilter;
+
+    /**
+     * Creates a filtered Request
+     *
+     * @param request a {@link Request} describing your Tests
+     * @param filter {@link Filter} to apply to the Tests described in
+     * <code>request</code>
+     */
+    public FilterRequest(Request request, Filter filter) {
+        this.request = request;
+        this.fFilter = filter;
+    }
+
+    @Override
+    public Runner getRunner() {
+        try {
+            Runner runner = request.getRunner();
+            fFilter.apply(runner);
+            return runner;
+        } catch (NoTestsRemainException e) {
+            return new ErrorReportingRunner(Filter.class, new Exception(String
+                    .format("No tests found matching %s from %s", fFilter
+                            .describe(), request.toString())));
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/MemoizingRequest.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/MemoizingRequest.java
new file mode 100644
index 0000000..191c230
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/MemoizingRequest.java
@@ -0,0 +1,30 @@
+package org.junit.internal.requests;
+
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.junit.runner.Request;
+import org.junit.runner.Runner;
+
+abstract class MemoizingRequest extends Request {
+    private final Lock runnerLock = new ReentrantLock();
+    private volatile Runner runner;
+
+    @Override
+    public final Runner getRunner() {
+        if (runner == null) {
+            runnerLock.lock();
+            try {
+                if (runner == null) {
+                    runner = createRunner();
+                }
+            } finally {
+                runnerLock.unlock();
+            }
+        }
+        return runner;
+    }
+
+    /** Creates the {@link Runner} to return from {@link #getRunner()}. Called at most once. */
+    protected abstract Runner createRunner();
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/OrderingRequest.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/OrderingRequest.java
new file mode 100644
index 0000000..441e595
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/OrderingRequest.java
@@ -0,0 +1,29 @@
+package org.junit.internal.requests;
+
+import org.junit.internal.runners.ErrorReportingRunner;
+import org.junit.runner.Request;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.InvalidOrderingException;
+import org.junit.runner.manipulation.Ordering;
+
+/** @since 4.13 */
+public class OrderingRequest extends MemoizingRequest {
+    private final Request request;
+    private final Ordering ordering;
+
+    public OrderingRequest(Request request, Ordering ordering) {
+        this.request = request;
+        this.ordering = ordering;
+    }
+
+    @Override
+    protected Runner createRunner() {
+        Runner runner = request.getRunner();
+        try {
+            ordering.apply(runner);
+        } catch (InvalidOrderingException e) {
+            return new ErrorReportingRunner(ordering.getClass(), e);
+        }
+        return runner;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/SortingRequest.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/SortingRequest.java
new file mode 100644
index 0000000..77061da
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/SortingRequest.java
@@ -0,0 +1,25 @@
+package org.junit.internal.requests;
+
+import java.util.Comparator;
+
+import org.junit.runner.Description;
+import org.junit.runner.Request;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Sorter;
+
+public class SortingRequest extends Request {
+    private final Request request;
+    private final Comparator<Description> comparator;
+
+    public SortingRequest(Request request, Comparator<Description> comparator) {
+        this.request = request;
+        this.comparator = comparator;
+    }
+
+    @Override
+    public Runner getRunner() {
+        Runner runner = request.getRunner();
+        new Sorter(comparator).apply(runner);
+        return runner;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/package-info.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/package-info.java
new file mode 100644
index 0000000..66d2928
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/requests/package-info.java
@@ -0,0 +1,6 @@
+/**
+ * Provides implementations of {@link org.junit.runner.Request}.
+ *
+ * @since 4.0
+ */
+package org.junit.internal.requests;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/ClassRoadie.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/ClassRoadie.java
new file mode 100644
index 0000000..df1b453
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/ClassRoadie.java
@@ -0,0 +1,81 @@
+package org.junit.internal.runners;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runner.Description;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+
+/**
+ * @deprecated Included for backwards compatibility with JUnit 4.4. Will be
+ *             removed in the next major release. Please use
+ *             {@link BlockJUnit4ClassRunner} in place of {@link JUnit4ClassRunner}.
+ */
+@Deprecated
+public class ClassRoadie {
+    private RunNotifier notifier;
+    private TestClass testClass;
+    private Description description;
+    private final Runnable runnable;
+
+    public ClassRoadie(RunNotifier notifier, TestClass testClass,
+            Description description, Runnable runnable) {
+        this.notifier = notifier;
+        this.testClass = testClass;
+        this.description = description;
+        this.runnable = runnable;
+    }
+
+    protected void runUnprotected() {
+        runnable.run();
+    }
+
+    protected void addFailure(Throwable targetException) {
+        notifier.fireTestFailure(new Failure(description, targetException));
+    }
+
+    public void runProtected() {
+        try {
+            runBefores();
+            runUnprotected();
+        } catch (FailedBefore e) {
+        } finally {
+            runAfters();
+        }
+    }
+
+    private void runBefores() throws FailedBefore {
+        try {
+            try {
+                List<Method> befores = testClass.getBefores();
+                for (Method before : befores) {
+                    before.invoke(null);
+                }
+            } catch (InvocationTargetException e) {
+                throw e.getTargetException();
+            }
+        } catch (AssumptionViolatedException e) {
+            throw new FailedBefore();
+        } catch (Throwable e) {
+            addFailure(e);
+            throw new FailedBefore();
+        }
+    }
+
+    private void runAfters() {
+        List<Method> afters = testClass.getAfters();
+        for (Method after : afters) {
+            try {
+                after.invoke(null);
+            } catch (InvocationTargetException e) {
+                addFailure(e.getTargetException());
+            } catch (Throwable e) {
+                addFailure(e); // Untested, but seems impossible
+            }
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/ErrorReportingRunner.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/ErrorReportingRunner.java
new file mode 100644
index 0000000..f52abab
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/ErrorReportingRunner.java
@@ -0,0 +1,92 @@
+package org.junit.internal.runners;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+
+import org.junit.runner.Description;
+import org.junit.runner.Runner;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.model.InvalidTestClassError;
+import org.junit.runners.model.InitializationError;
+
+import static java.util.Collections.singletonList;
+
+public class ErrorReportingRunner extends Runner {
+    private final List<Throwable> causes;
+
+    private final String classNames;
+
+    public ErrorReportingRunner(Class<?> testClass, Throwable cause) {
+        this(cause, testClass);
+    }
+    
+    public ErrorReportingRunner(Throwable cause, Class<?>... testClasses) {
+        if (testClasses == null || testClasses.length == 0) {
+            throw new NullPointerException("Test classes cannot be null or empty");
+        }
+        for (Class<?> testClass : testClasses) {
+            if (testClass == null) {
+                throw new NullPointerException("Test class cannot be null");
+            }
+        }
+        classNames = getClassNames(testClasses);
+        causes = getCauses(cause);
+    }
+    
+    @Override
+    public Description getDescription() {
+        Description description = Description.createSuiteDescription(classNames);
+        for (Throwable each : causes) {
+            description.addChild(describeCause());
+        }
+        return description;
+    }
+
+    @Override
+    public void run(RunNotifier notifier) {
+        for (Throwable each : causes) {
+            runCause(each, notifier);
+        }
+    }
+
+    private String getClassNames(Class<?>... testClasses) {
+        final StringBuilder builder = new StringBuilder();
+        for (Class<?> testClass : testClasses) {
+            if (builder.length() != 0) {
+                builder.append(", ");
+            }
+            builder.append(testClass.getName());
+        }
+        return builder.toString();
+    }
+
+    @SuppressWarnings("deprecation")
+    private List<Throwable> getCauses(Throwable cause) {
+        if (cause instanceof InvocationTargetException) {
+            return getCauses(cause.getCause());
+        }
+        if (cause instanceof InvalidTestClassError) {
+            return singletonList(cause);
+        }
+        if (cause instanceof InitializationError) {
+            return ((InitializationError) cause).getCauses();
+        }
+        if (cause instanceof org.junit.internal.runners.InitializationError) {
+            return ((org.junit.internal.runners.InitializationError) cause)
+                    .getCauses();
+        }
+        return singletonList(cause);
+    }
+
+    private Description describeCause() {
+        return Description.createTestDescription(classNames, "initializationError");
+    }
+
+    private void runCause(Throwable child, RunNotifier notifier) {
+        Description description = describeCause();
+        notifier.fireTestStarted(description);
+        notifier.fireTestFailure(new Failure(description, child));
+        notifier.fireTestFinished(description);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/FailedBefore.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/FailedBefore.java
new file mode 100644
index 0000000..1036cb6
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/FailedBefore.java
@@ -0,0 +1,13 @@
+package org.junit.internal.runners;
+
+import org.junit.runners.BlockJUnit4ClassRunner;
+
+/**
+ * @deprecated Included for backwards compatibility with JUnit 4.4. Will be
+ *             removed in the next major release. Please use
+ *             {@link BlockJUnit4ClassRunner} in place of {@link JUnit4ClassRunner}.
+ */
+@Deprecated
+class FailedBefore extends Exception {
+    private static final long serialVersionUID = 1L;
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/InitializationError.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/InitializationError.java
new file mode 100644
index 0000000..484f58d
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/InitializationError.java
@@ -0,0 +1,37 @@
+package org.junit.internal.runners;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Use the published version:
+ * {@link org.junit.runners.model.InitializationError}
+ * This may disappear as soon as 1 April 2009
+ */
+@Deprecated
+public class InitializationError extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit4/issues/976
+     */
+    private final List<Throwable> fErrors;
+
+    public InitializationError(List<Throwable> errors) {
+        this.fErrors = errors;
+    }
+
+    public InitializationError(Throwable... errors) {
+        this(Arrays.asList(errors));
+    }
+
+    public InitializationError(String string) {
+        this(new Exception(string));
+    }
+
+    public List<Throwable> getCauses() {
+        return fErrors;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/JUnit38ClassRunner.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/JUnit38ClassRunner.java
new file mode 100644
index 0000000..0d51541
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/JUnit38ClassRunner.java
@@ -0,0 +1,196 @@
+package org.junit.internal.runners;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+
+import junit.extensions.TestDecorator;
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestListener;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+import org.junit.runner.Describable;
+import org.junit.runner.Description;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.Filterable;
+import org.junit.runner.manipulation.Orderer;
+import org.junit.runner.manipulation.InvalidOrderingException;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runner.manipulation.Orderable;
+import org.junit.runner.manipulation.Sortable;
+import org.junit.runner.manipulation.Sorter;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunNotifier;
+
+public class JUnit38ClassRunner extends Runner implements Filterable, Orderable {
+    private static final class OldTestClassAdaptingListener implements
+            TestListener {
+        private final RunNotifier notifier;
+
+        private OldTestClassAdaptingListener(RunNotifier notifier) {
+            this.notifier = notifier;
+        }
+
+        public void endTest(Test test) {
+            notifier.fireTestFinished(asDescription(test));
+        }
+
+        public void startTest(Test test) {
+            notifier.fireTestStarted(asDescription(test));
+        }
+
+        // Implement junit.framework.TestListener
+        public void addError(Test test, Throwable e) {
+            Failure failure = new Failure(asDescription(test), e);
+            notifier.fireTestFailure(failure);
+        }
+
+        private Description asDescription(Test test) {
+            if (test instanceof Describable) {
+                Describable facade = (Describable) test;
+                return facade.getDescription();
+            }
+            return Description.createTestDescription(getEffectiveClass(test), getName(test));
+        }
+
+        private Class<? extends Test> getEffectiveClass(Test test) {
+            return test.getClass();
+        }
+
+        private String getName(Test test) {
+            if (test instanceof TestCase) {
+                return ((TestCase) test).getName();
+            } else {
+                return test.toString();
+            }
+        }
+
+        public void addFailure(Test test, AssertionFailedError t) {
+            addError(test, t);
+        }
+    }
+
+    private volatile Test test;
+
+    public JUnit38ClassRunner(Class<?> klass) {
+        this(new TestSuite(klass.asSubclass(TestCase.class)));
+    }
+
+    public JUnit38ClassRunner(Test test) {
+        super();
+        setTest(test);
+    }
+
+    @Override
+    public void run(RunNotifier notifier) {
+        TestResult result = new TestResult();
+        result.addListener(createAdaptingListener(notifier));
+        getTest().run(result);
+    }
+
+    public TestListener createAdaptingListener(final RunNotifier notifier) {
+        return new OldTestClassAdaptingListener(notifier);
+    }
+
+    @Override
+    public Description getDescription() {
+        return makeDescription(getTest());
+    }
+
+    private static Description makeDescription(Test test) {
+        if (test instanceof TestCase) {
+            TestCase tc = (TestCase) test;
+            return Description.createTestDescription(tc.getClass(), tc.getName(),
+                    getAnnotations(tc));
+        } else if (test instanceof TestSuite) {
+            TestSuite ts = (TestSuite) test;
+            String name = ts.getName() == null ? createSuiteDescription(ts) : ts.getName();
+            Description description = Description.createSuiteDescription(name);
+            int n = ts.testCount();
+            for (int i = 0; i < n; i++) {
+                Description made = makeDescription(ts.testAt(i));
+                description.addChild(made);
+            }
+            return description;
+        } else if (test instanceof Describable) {
+            Describable adapter = (Describable) test;
+            return adapter.getDescription();
+        } else if (test instanceof TestDecorator) {
+            TestDecorator decorator = (TestDecorator) test;
+            return makeDescription(decorator.getTest());
+        } else {
+            // This is the best we can do in this case
+            return Description.createSuiteDescription(test.getClass());
+        }
+    }
+
+    /**
+     * Get the annotations associated with given TestCase.
+     * @param test the TestCase.
+     */
+    private static Annotation[] getAnnotations(TestCase test) {
+        try {
+            Method m = test.getClass().getMethod(test.getName());
+            return m.getDeclaredAnnotations();
+        } catch (SecurityException e) {
+        } catch (NoSuchMethodException e) {
+        }
+        return new Annotation[0];
+    }
+
+    private static String createSuiteDescription(TestSuite ts) {
+        int count = ts.countTestCases();
+        String example = count == 0 ? "" : String.format(" [example: %s]", ts.testAt(0));
+        return String.format("TestSuite with %s tests%s", count, example);
+    }
+
+    public void filter(Filter filter) throws NoTestsRemainException {
+        if (getTest() instanceof Filterable) {
+            Filterable adapter = (Filterable) getTest();
+            adapter.filter(filter);
+        } else if (getTest() instanceof TestSuite) {
+            TestSuite suite = (TestSuite) getTest();
+            TestSuite filtered = new TestSuite(suite.getName());
+            int n = suite.testCount();
+            for (int i = 0; i < n; i++) {
+                Test test = suite.testAt(i);
+                if (filter.shouldRun(makeDescription(test))) {
+                    filtered.addTest(test);
+                }
+            }
+            setTest(filtered);
+            if (filtered.testCount() == 0) {
+                throw new NoTestsRemainException();
+            }
+        }
+    }
+
+    public void sort(Sorter sorter) {
+        if (getTest() instanceof Sortable) {
+            Sortable adapter = (Sortable) getTest();
+            adapter.sort(sorter);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @since 4.13
+     */
+    public void order(Orderer orderer) throws InvalidOrderingException {
+        if (getTest() instanceof Orderable) {
+            Orderable adapter = (Orderable) getTest();
+            adapter.order(orderer);
+        }
+    }
+
+    private void setTest(Test test) {
+        this.test = test;
+    }
+
+    private Test getTest() {
+        return test;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/JUnit4ClassRunner.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/JUnit4ClassRunner.java
new file mode 100644
index 0000000..69a23c4
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/JUnit4ClassRunner.java
@@ -0,0 +1,147 @@
+package org.junit.internal.runners;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+
+import org.junit.runner.Description;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.Filterable;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runner.manipulation.Sortable;
+import org.junit.runner.manipulation.Sorter;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+
+/**
+ * @deprecated Included for backwards compatibility with JUnit 4.4. Will be
+ *             removed in the next major release. Please use
+ *             {@link BlockJUnit4ClassRunner} in place of {@link JUnit4ClassRunner}.
+ */
+@Deprecated
+public class JUnit4ClassRunner extends Runner implements Filterable, Sortable {
+    private final List<Method> testMethods;
+    private TestClass testClass;
+
+    public JUnit4ClassRunner(Class<?> klass) throws InitializationError {
+        testClass = new TestClass(klass);
+        testMethods = getTestMethods();
+        validate();
+    }
+
+    protected List<Method> getTestMethods() {
+        return testClass.getTestMethods();
+    }
+
+    protected void validate() throws InitializationError {
+        MethodValidator methodValidator = new MethodValidator(testClass);
+        methodValidator.validateMethodsForDefaultRunner();
+        methodValidator.assertValid();
+    }
+
+    @Override
+    public void run(final RunNotifier notifier) {
+        new ClassRoadie(notifier, testClass, getDescription(), new Runnable() {
+            public void run() {
+                runMethods(notifier);
+            }
+        }).runProtected();
+    }
+
+    protected void runMethods(final RunNotifier notifier) {
+        for (Method method : testMethods) {
+            invokeTestMethod(method, notifier);
+        }
+    }
+
+    @Override
+    public Description getDescription() {
+        Description spec = Description.createSuiteDescription(getName(), classAnnotations());
+        List<Method> testMethods = this.testMethods;
+        for (Method method : testMethods) {
+            spec.addChild(methodDescription(method));
+        }
+        return spec;
+    }
+
+    protected Annotation[] classAnnotations() {
+        return testClass.getJavaClass().getAnnotations();
+    }
+
+    protected String getName() {
+        return getTestClass().getName();
+    }
+
+    protected Object createTest() throws Exception {
+        return getTestClass().getConstructor().newInstance();
+    }
+
+    protected void invokeTestMethod(Method method, RunNotifier notifier) {
+        Description description = methodDescription(method);
+        Object test;
+        try {
+            test = createTest();
+        } catch (InvocationTargetException e) {
+            testAborted(notifier, description, e.getCause());
+            return;
+        } catch (Exception e) {
+            testAborted(notifier, description, e);
+            return;
+        }
+        TestMethod testMethod = wrapMethod(method);
+        new MethodRoadie(test, testMethod, notifier, description).run();
+    }
+
+    private void testAborted(RunNotifier notifier, Description description,
+            Throwable e) {
+        notifier.fireTestStarted(description);
+        notifier.fireTestFailure(new Failure(description, e));
+        notifier.fireTestFinished(description);
+    }
+
+    protected TestMethod wrapMethod(Method method) {
+        return new TestMethod(method, testClass);
+    }
+
+    protected String testName(Method method) {
+        return method.getName();
+    }
+
+    protected Description methodDescription(Method method) {
+        return Description.createTestDescription(getTestClass().getJavaClass(), testName(method), testAnnotations(method));
+    }
+
+    protected Annotation[] testAnnotations(Method method) {
+        return method.getAnnotations();
+    }
+
+    public void filter(Filter filter) throws NoTestsRemainException {
+        for (Iterator<Method> iter = testMethods.iterator(); iter.hasNext(); ) {
+            Method method = iter.next();
+            if (!filter.shouldRun(methodDescription(method))) {
+                iter.remove();
+            }
+        }
+        if (testMethods.isEmpty()) {
+            throw new NoTestsRemainException();
+        }
+    }
+
+    public void sort(final Sorter sorter) {
+        Collections.sort(testMethods, new Comparator<Method>() {
+            public int compare(Method o1, Method o2) {
+                return sorter.compare(methodDescription(o1), methodDescription(o2));
+            }
+        });
+    }
+
+    protected TestClass getTestClass() {
+        return testClass;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/MethodRoadie.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/MethodRoadie.java
new file mode 100644
index 0000000..01a476b
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/MethodRoadie.java
@@ -0,0 +1,163 @@
+package org.junit.internal.runners;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runner.Description;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.TestTimedOutException;
+
+/**
+ * @deprecated Included for backwards compatibility with JUnit 4.4. Will be
+ *             removed in the next major release. Please use
+ *             {@link BlockJUnit4ClassRunner} in place of {@link JUnit4ClassRunner}.
+ */
+@Deprecated
+public class MethodRoadie {
+    private final Object test;
+    private final RunNotifier notifier;
+    private final Description description;
+    private TestMethod testMethod;
+
+    public MethodRoadie(Object test, TestMethod method, RunNotifier notifier, Description description) {
+        this.test = test;
+        this.notifier = notifier;
+        this.description = description;
+        testMethod = method;
+    }
+
+    public void run() {
+        if (testMethod.isIgnored()) {
+            notifier.fireTestIgnored(description);
+            return;
+        }
+        notifier.fireTestStarted(description);
+        try {
+            long timeout = testMethod.getTimeout();
+            if (timeout > 0) {
+                runWithTimeout(timeout);
+            } else {
+                runTest();
+            }
+        } finally {
+            notifier.fireTestFinished(description);
+        }
+    }
+
+    private void runWithTimeout(final long timeout) {
+        runBeforesThenTestThenAfters(new Runnable() {
+
+            public void run() {
+                ExecutorService service = Executors.newSingleThreadExecutor();
+                Callable<Object> callable = new Callable<Object>() {
+                    public Object call() throws Exception {
+                        runTestMethod();
+                        return null;
+                    }
+                };
+                Future<Object> result = service.submit(callable);
+                service.shutdown();
+                try {
+                    boolean terminated = service.awaitTermination(timeout,
+                            TimeUnit.MILLISECONDS);
+                    if (!terminated) {
+                        service.shutdownNow();
+                    }
+                    result.get(0, TimeUnit.MILLISECONDS); // throws the exception if one occurred during the invocation
+                } catch (TimeoutException e) {
+                    addFailure(new TestTimedOutException(timeout, TimeUnit.MILLISECONDS));
+                } catch (Exception e) {
+                    addFailure(e);
+                }
+            }
+        });
+    }
+
+    public void runTest() {
+        runBeforesThenTestThenAfters(new Runnable() {
+            public void run() {
+                runTestMethod();
+            }
+        });
+    }
+
+    public void runBeforesThenTestThenAfters(Runnable test) {
+        try {
+            runBefores();
+            test.run();
+        } catch (FailedBefore e) {
+        } catch (Exception e) {
+            throw new RuntimeException("test should never throw an exception to this level");
+        } finally {
+            runAfters();
+        }
+    }
+
+    protected void runTestMethod() {
+        try {
+            testMethod.invoke(test);
+            if (testMethod.expectsException()) {
+                addFailure(new AssertionError("Expected exception: " + testMethod.getExpectedException().getName()));
+            }
+        } catch (InvocationTargetException e) {
+            Throwable actual = e.getTargetException();
+            if (actual instanceof AssumptionViolatedException) {
+                return;
+            } else if (!testMethod.expectsException()) {
+                addFailure(actual);
+            } else if (testMethod.isUnexpected(actual)) {
+                String message = "Unexpected exception, expected<" + testMethod.getExpectedException().getName() + "> but was<"
+                        + actual.getClass().getName() + ">";
+                addFailure(new Exception(message, actual));
+            }
+        } catch (Throwable e) {
+            addFailure(e);
+        }
+    }
+
+    private void runBefores() throws FailedBefore {
+        try {
+            try {
+                List<Method> befores = testMethod.getBefores();
+                for (Method before : befores) {
+                    before.invoke(test);
+                }
+            } catch (InvocationTargetException e) {
+                throw e.getTargetException();
+            }
+        } catch (AssumptionViolatedException e) {
+            throw new FailedBefore();
+        } catch (Throwable e) {
+            addFailure(e);
+            throw new FailedBefore();
+        }
+    }
+
+    private void runAfters() {
+        List<Method> afters = testMethod.getAfters();
+        for (Method after : afters) {
+            try {
+                after.invoke(test);
+            } catch (InvocationTargetException e) {
+                addFailure(e.getTargetException());
+            } catch (Throwable e) {
+                addFailure(e); // Untested, but seems impossible
+            }
+        }
+    }
+
+    protected void addFailure(Throwable e) {
+        notifier.fireTestFailure(new Failure(description, e));
+    }
+}
+
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/MethodValidator.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/MethodValidator.java
new file mode 100644
index 0000000..e656ee5
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/MethodValidator.java
@@ -0,0 +1,97 @@
+package org.junit.internal.runners;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runners.BlockJUnit4ClassRunner;
+
+/**
+ * @deprecated Included for backwards compatibility with JUnit 4.4. Will be
+ *             removed in the next major release. Please use
+ *             {@link BlockJUnit4ClassRunner} in place of {@link JUnit4ClassRunner}.
+ */
+@Deprecated
+public class MethodValidator {
+
+    private final List<Throwable> errors = new ArrayList<Throwable>();
+
+    private TestClass testClass;
+
+    public MethodValidator(TestClass testClass) {
+        this.testClass = testClass;
+    }
+
+    public void validateInstanceMethods() {
+        validateTestMethods(After.class, false);
+        validateTestMethods(Before.class, false);
+        validateTestMethods(Test.class, false);
+
+        List<Method> methods = testClass.getAnnotatedMethods(Test.class);
+        if (methods.size() == 0) {
+            errors.add(new Exception("No runnable methods"));
+        }
+    }
+
+    public void validateStaticMethods() {
+        validateTestMethods(BeforeClass.class, true);
+        validateTestMethods(AfterClass.class, true);
+    }
+
+    public List<Throwable> validateMethodsForDefaultRunner() {
+        validateNoArgConstructor();
+        validateStaticMethods();
+        validateInstanceMethods();
+        return errors;
+    }
+
+    public void assertValid() throws InitializationError {
+        if (!errors.isEmpty()) {
+            throw new InitializationError(errors);
+        }
+    }
+
+    public void validateNoArgConstructor() {
+        try {
+            testClass.getConstructor();
+        } catch (Exception e) {
+            errors.add(new Exception("Test class should have public zero-argument constructor", e));
+        }
+    }
+
+    private void validateTestMethods(Class<? extends Annotation> annotation,
+            boolean isStatic) {
+        List<Method> methods = testClass.getAnnotatedMethods(annotation);
+
+        for (Method each : methods) {
+            if (Modifier.isStatic(each.getModifiers()) != isStatic) {
+                String state = isStatic ? "should" : "should not";
+                errors.add(new Exception("Method " + each.getName() + "() "
+						+ state + " be static"));
+            }
+            if (!Modifier.isPublic(each.getDeclaringClass().getModifiers())) {
+                errors.add(new Exception("Class " + each.getDeclaringClass().getName()
+						+ " should be public"));
+            }
+            if (!Modifier.isPublic(each.getModifiers())) {
+                errors.add(new Exception("Method " + each.getName()
+						+ " should be public"));
+            }
+            if (each.getReturnType() != Void.TYPE) {
+                errors.add(new Exception("Method " + each.getName()
+						+ "should have a return type of void"));
+            }
+            if (each.getParameterTypes().length != 0) {
+                errors.add(new Exception("Method " + each.getName()
+						+ " should have no parameters"));
+            }
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/SuiteMethod.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/SuiteMethod.java
new file mode 100644
index 0000000..e336983
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/SuiteMethod.java
@@ -0,0 +1,41 @@
+package org.junit.internal.runners;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import junit.framework.Test;
+
+/**
+ * Runner for use with JUnit 3.8.x-style AllTests classes
+ * (those that only implement a static <code>suite()</code>
+ * method). For example:
+ * <pre>
+ * &#064;RunWith(AllTests.class)
+ * public class ProductTests {
+ *    public static junit.framework.Test suite() {
+ *       ...
+ *    }
+ * }
+ * </pre>
+ */
+public class SuiteMethod extends JUnit38ClassRunner {
+    public SuiteMethod(Class<?> klass) throws Throwable {
+        super(testFromSuiteMethod(klass));
+    }
+
+    public static Test testFromSuiteMethod(Class<?> klass) throws Throwable {
+        Method suiteMethod = null;
+        Test suite = null;
+        try {
+            suiteMethod = klass.getMethod("suite");
+            if (!Modifier.isStatic(suiteMethod.getModifiers())) {
+                throw new Exception(klass.getName() + ".suite() must be static");
+            }
+            suite = (Test) suiteMethod.invoke(null); // static method
+        } catch (InvocationTargetException e) {
+            throw e.getCause();
+        }
+        return suite;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/TestClass.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/TestClass.java
new file mode 100644
index 0000000..6d24f4f
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/TestClass.java
@@ -0,0 +1,109 @@
+package org.junit.internal.runners;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.internal.MethodSorter;
+import org.junit.runners.BlockJUnit4ClassRunner;
+
+/**
+ * @deprecated Included for backwards compatibility with JUnit 4.4. Will be
+ *             removed in the next major release. Please use
+ *             {@link BlockJUnit4ClassRunner} in place of {@link JUnit4ClassRunner}.
+ */
+@Deprecated
+public class TestClass {
+    private final Class<?> klass;
+
+    public TestClass(Class<?> klass) {
+        this.klass = klass;
+    }
+
+    public List<Method> getTestMethods() {
+        return getAnnotatedMethods(Test.class);
+    }
+
+    List<Method> getBefores() {
+        return getAnnotatedMethods(BeforeClass.class);
+    }
+
+    List<Method> getAfters() {
+        return getAnnotatedMethods(AfterClass.class);
+    }
+
+    public List<Method> getAnnotatedMethods(Class<? extends Annotation> annotationClass) {
+        List<Method> results = new ArrayList<Method>();
+        for (Class<?> eachClass : getSuperClasses(klass)) {
+            Method[] methods = MethodSorter.getDeclaredMethods(eachClass);
+            for (Method eachMethod : methods) {
+                Annotation annotation = eachMethod.getAnnotation(annotationClass);
+                if (annotation != null && !isShadowed(eachMethod, results)) {
+                    results.add(eachMethod);
+                }
+            }
+        }
+        if (runsTopToBottom(annotationClass)) {
+            Collections.reverse(results);
+        }
+        return results;
+    }
+
+    private boolean runsTopToBottom(Class<? extends Annotation> annotation) {
+        return annotation.equals(Before.class) || annotation.equals(BeforeClass.class);
+    }
+
+    private boolean isShadowed(Method method, List<Method> results) {
+        for (Method each : results) {
+            if (isShadowed(method, each)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isShadowed(Method current, Method previous) {
+        if (!previous.getName().equals(current.getName())) {
+            return false;
+        }
+        if (previous.getParameterTypes().length != current.getParameterTypes().length) {
+            return false;
+        }
+        for (int i = 0; i < previous.getParameterTypes().length; i++) {
+            if (!previous.getParameterTypes()[i].equals(current.getParameterTypes()[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private List<Class<?>> getSuperClasses(Class<?> testClass) {
+        List<Class<?>> results = new ArrayList<Class<?>>();
+        Class<?> current = testClass;
+        while (current != null) {
+            results.add(current);
+            current = current.getSuperclass();
+        }
+        return results;
+    }
+
+    public Constructor<?> getConstructor() throws SecurityException, NoSuchMethodException {
+        return klass.getConstructor();
+    }
+
+    public Class<?> getJavaClass() {
+        return klass;
+    }
+
+    public String getName() {
+        return klass.getName();
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/TestMethod.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/TestMethod.java
new file mode 100644
index 0000000..821e193
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/TestMethod.java
@@ -0,0 +1,71 @@
+package org.junit.internal.runners;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.Test.None;
+import org.junit.runners.BlockJUnit4ClassRunner;
+
+/**
+ * @deprecated Included for backwards compatibility with JUnit 4.4. Will be
+ *             removed in the next major release. Please use
+ *             {@link BlockJUnit4ClassRunner} in place of {@link JUnit4ClassRunner}.
+ */
+@Deprecated
+public class TestMethod {
+    private final Method method;
+    private TestClass testClass;
+
+    public TestMethod(Method method, TestClass testClass) {
+        this.method = method;
+        this.testClass = testClass;
+    }
+
+    public boolean isIgnored() {
+        return method.getAnnotation(Ignore.class) != null;
+    }
+
+    public long getTimeout() {
+        Test annotation = method.getAnnotation(Test.class);
+        if (annotation == null) {
+            return 0;
+        }
+        long timeout = annotation.timeout();
+        return timeout;
+    }
+
+    protected Class<? extends Throwable> getExpectedException() {
+        Test annotation = method.getAnnotation(Test.class);
+        if (annotation == null || annotation.expected() == None.class) {
+            return null;
+        } else {
+            return annotation.expected();
+        }
+    }
+
+    boolean isUnexpected(Throwable exception) {
+        return !getExpectedException().isAssignableFrom(exception.getClass());
+    }
+
+    boolean expectsException() {
+        return getExpectedException() != null;
+    }
+
+    List<Method> getBefores() {
+        return testClass.getAnnotatedMethods(Before.class);
+    }
+
+    List<Method> getAfters() {
+        return testClass.getAnnotatedMethods(After.class);
+    }
+
+    public void invoke(Object test) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
+        method.invoke(test);
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/model/EachTestNotifier.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/model/EachTestNotifier.java
new file mode 100644
index 0000000..c5a0764
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/model/EachTestNotifier.java
@@ -0,0 +1,71 @@
+package org.junit.internal.runners.model;
+
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runner.Description;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.model.MultipleFailureException;
+
+public class EachTestNotifier {
+    private final RunNotifier notifier;
+
+    private final Description description;
+
+    public EachTestNotifier(RunNotifier notifier, Description description) {
+        this.notifier = notifier;
+        this.description = description;
+    }
+
+    public void addFailure(Throwable targetException) {
+        if (targetException instanceof MultipleFailureException) {
+            addMultipleFailureException((MultipleFailureException) targetException);
+        } else {
+            notifier.fireTestFailure(new Failure(description, targetException));
+        }
+    }
+
+    private void addMultipleFailureException(MultipleFailureException mfe) {
+        for (Throwable each : mfe.getFailures()) {
+            addFailure(each);
+        }
+    }
+
+    public void addFailedAssumption(AssumptionViolatedException e) {
+        notifier.fireTestAssumptionFailed(new Failure(description, e));
+    }
+
+    public void fireTestFinished() {
+        notifier.fireTestFinished(description);
+    }
+
+    public void fireTestStarted() {
+        notifier.fireTestStarted(description);
+    }
+
+    public void fireTestIgnored() {
+        notifier.fireTestIgnored(description);
+    }
+
+    /**
+     * Calls {@link RunNotifier#fireTestSuiteStarted(Description)}, passing the
+     * {@link Description} that was passed to the {@code EachTestNotifier} constructor.
+     * This should be called when a test suite is about to be started.
+     * @see RunNotifier#fireTestSuiteStarted(Description)
+     * @since 4.13
+     */
+    public void fireTestSuiteStarted() {
+        notifier.fireTestSuiteStarted(description);
+    }
+
+    /**
+     * Calls {@link RunNotifier#fireTestSuiteFinished(Description)}, passing the
+     * {@link Description} that was passed to the {@code EachTestNotifier} constructor.
+     * This should be called when a test suite has finished, whether the test suite succeeds
+     * or fails.
+     * @see RunNotifier#fireTestSuiteFinished(Description)
+     * @since 4.13
+     */
+    public void fireTestSuiteFinished() {
+        notifier.fireTestSuiteFinished(description);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/model/MultipleFailureException.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/model/MultipleFailureException.java
new file mode 100644
index 0000000..054f042
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/model/MultipleFailureException.java
@@ -0,0 +1,12 @@
+package org.junit.internal.runners.model;
+
+import java.util.List;
+
+@Deprecated
+public class MultipleFailureException extends org.junit.runners.model.MultipleFailureException {
+    private static final long serialVersionUID = 1L;
+
+    public MultipleFailureException(List<Throwable> errors) {
+        super(errors);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/model/ReflectiveCallable.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/model/ReflectiveCallable.java
new file mode 100644
index 0000000..79d5c05
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/model/ReflectiveCallable.java
@@ -0,0 +1,19 @@
+package org.junit.internal.runners.model;
+
+import java.lang.reflect.InvocationTargetException;
+
+/**
+ * When invoked, throws the exception from the reflected method, rather than
+ * wrapping it in an InvocationTargetException.
+ */
+public abstract class ReflectiveCallable {
+    public Object run() throws Throwable {
+        try {
+            return runReflectiveCall();
+        } catch (InvocationTargetException e) {
+            throw e.getTargetException();
+        }
+    }
+
+    protected abstract Object runReflectiveCall() throws Throwable;
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/package-info.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/package-info.java
new file mode 100644
index 0000000..5ab7e7b
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/package-info.java
@@ -0,0 +1,6 @@
+/**
+ * Provides implementations of {@link org.junit.runner.Runner}
+ *
+ * @since 4.0
+ */
+package org.junit.internal.runners;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/rules/RuleMemberValidator.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/rules/RuleMemberValidator.java
new file mode 100644
index 0000000..36de4f1
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/rules/RuleMemberValidator.java
@@ -0,0 +1,279 @@
+package org.junit.internal.runners.rules;
+
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.rules.MethodRule;
+import org.junit.rules.TestRule;
+import org.junit.runners.model.FrameworkMember;
+import org.junit.runners.model.TestClass;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A RuleMemberValidator validates the rule fields/methods of a
+ * {@link org.junit.runners.model.TestClass}. All reasons for rejecting the
+ * {@code TestClass} are written to a list of errors.
+ *
+ * <p>There are four slightly different validators. The {@link #CLASS_RULE_VALIDATOR}
+ * validates fields with a {@link ClassRule} annotation and the
+ * {@link #RULE_VALIDATOR} validates fields with a {@link Rule} annotation.</p>
+ *
+ * <p>The {@link #CLASS_RULE_METHOD_VALIDATOR}
+ * validates methods with a {@link ClassRule} annotation and the
+ * {@link #RULE_METHOD_VALIDATOR} validates methods with a {@link Rule} annotation.</p>
+ */
+public class RuleMemberValidator {
+    /**
+     * Validates fields with a {@link ClassRule} annotation.
+     */
+    public static final RuleMemberValidator CLASS_RULE_VALIDATOR =
+            classRuleValidatorBuilder()
+            .withValidator(new DeclaringClassMustBePublic())
+            .withValidator(new MemberMustBeStatic())
+            .withValidator(new MemberMustBePublic())
+            .withValidator(new FieldMustBeATestRule())
+            .build();
+    /**
+     * Validates fields with a {@link Rule} annotation.
+     */
+    public static final RuleMemberValidator RULE_VALIDATOR =
+            testRuleValidatorBuilder()
+            .withValidator(new MemberMustBeNonStaticOrAlsoClassRule())
+            .withValidator(new MemberMustBePublic())
+            .withValidator(new FieldMustBeARule())
+            .build();
+    /**
+     * Validates methods with a {@link ClassRule} annotation.
+     */
+    public static final RuleMemberValidator CLASS_RULE_METHOD_VALIDATOR =
+            classRuleValidatorBuilder()
+            .forMethods()
+            .withValidator(new DeclaringClassMustBePublic())
+            .withValidator(new MemberMustBeStatic())
+            .withValidator(new MemberMustBePublic())
+            .withValidator(new MethodMustBeATestRule())
+            .build();
+
+    /**
+     * Validates methods with a {@link Rule} annotation.
+     */
+    public static final RuleMemberValidator RULE_METHOD_VALIDATOR =
+            testRuleValidatorBuilder()
+            .forMethods()
+            .withValidator(new MemberMustBeNonStaticOrAlsoClassRule())
+            .withValidator(new MemberMustBePublic())
+            .withValidator(new MethodMustBeARule())
+            .build();
+
+    private final Class<? extends Annotation> annotation;
+    private final boolean methods;
+    private final List<RuleValidator> validatorStrategies;
+
+    RuleMemberValidator(Builder builder) {
+        this.annotation = builder.annotation;
+        this.methods = builder.methods;
+        this.validatorStrategies = builder.validators;
+    }
+
+    /**
+     * Validate the {@link org.junit.runners.model.TestClass} and adds reasons
+     * for rejecting the class to a list of errors.
+     *
+     * @param target the {@code TestClass} to validate.
+     * @param errors the list of errors.
+     */
+    public void validate(TestClass target, List<Throwable> errors) {
+        List<? extends FrameworkMember<?>> members = methods ? target.getAnnotatedMethods(annotation)
+                : target.getAnnotatedFields(annotation);
+
+        for (FrameworkMember<?> each : members) {
+            validateMember(each, errors);
+        }
+    }
+
+    private void validateMember(FrameworkMember<?> member, List<Throwable> errors) {
+        for (RuleValidator strategy : validatorStrategies) {
+            strategy.validate(member, annotation, errors);
+        }
+    }
+
+    private static Builder classRuleValidatorBuilder() {
+        return new Builder(ClassRule.class);
+    }
+
+    private static Builder testRuleValidatorBuilder() {
+        return new Builder(Rule.class);
+    }
+
+    private static class Builder {
+        private final Class<? extends Annotation> annotation;
+        private boolean methods;
+        private final List<RuleValidator> validators;
+
+        private Builder(Class<? extends Annotation> annotation) {
+            this.annotation = annotation;
+            this.methods = false;
+            this.validators = new ArrayList<RuleValidator>();
+        }
+
+        Builder forMethods() {
+            methods = true;
+            return this;
+        }
+
+        Builder withValidator(RuleValidator validator) {
+            validators.add(validator);
+            return this;
+        }
+
+        RuleMemberValidator build() {
+            return new RuleMemberValidator(this);
+        }
+    }
+
+    private static boolean isRuleType(FrameworkMember<?> member) {
+        return isMethodRule(member) || isTestRule(member);
+    }
+
+    private static boolean isTestRule(FrameworkMember<?> member) {
+        return TestRule.class.isAssignableFrom(member.getType());
+    }
+
+    private static boolean isMethodRule(FrameworkMember<?> member) {
+        return MethodRule.class.isAssignableFrom(member.getType());
+    }
+
+    /**
+     * Encapsulates a single piece of validation logic, used to determine if {@link org.junit.Rule} and
+     * {@link org.junit.ClassRule} annotations have been used correctly
+     */
+    interface RuleValidator {
+        /**
+         * Examine the given member and add any violations of the strategy's validation logic to the given list of errors
+         * @param member The member (field or member) to examine
+         * @param annotation The type of rule annotation on the member
+         * @param errors The list of errors to add validation violations to
+         */
+        void validate(FrameworkMember<?> member, Class<? extends Annotation> annotation, List<Throwable> errors);
+    }
+
+    /**
+     * Requires the validated member to be non-static
+     */
+    private static final class MemberMustBeNonStaticOrAlsoClassRule implements RuleValidator {
+        public void validate(FrameworkMember<?> member, Class<? extends Annotation> annotation, List<Throwable> errors) {
+            boolean isMethodRuleMember = isMethodRule(member);
+            boolean isClassRuleAnnotated = (member.getAnnotation(ClassRule.class) != null);
+
+            // We disallow:
+            //  - static MethodRule members
+            //  - static @Rule annotated members
+            //    - UNLESS they're also @ClassRule annotated
+            // Note that MethodRule cannot be annotated with @ClassRule
+            if (member.isStatic() && (isMethodRuleMember || !isClassRuleAnnotated)) {
+                String message;
+                if (isMethodRule(member)) {
+                    message = "must not be static.";
+                } else {
+                    message = "must not be static or it must be annotated with @ClassRule.";
+                }
+                errors.add(new ValidationError(member, annotation, message));
+            }
+        }
+    }
+
+    /**
+     * Requires the member to be static
+     */
+    private static final class MemberMustBeStatic implements RuleValidator {
+        public void validate(FrameworkMember<?> member, Class<? extends Annotation> annotation, List<Throwable> errors) {
+            if (!member.isStatic()) {
+                errors.add(new ValidationError(member, annotation,
+                        "must be static."));
+            }
+        }
+    }
+
+    /**
+     * Requires the member's declaring class to be public
+     */
+    private static final class DeclaringClassMustBePublic implements RuleValidator {
+        public void validate(FrameworkMember<?> member, Class<? extends Annotation> annotation, List<Throwable> errors) {
+            if (!isDeclaringClassPublic(member)) {
+                errors.add(new ValidationError(member, annotation,
+                        "must be declared in a public class."));
+            }
+        }
+
+        private boolean isDeclaringClassPublic(FrameworkMember<?> member) {
+            return Modifier.isPublic(member.getDeclaringClass().getModifiers());
+        }
+    }
+
+    /**
+     * Requires the member to be public
+     */
+    private static final class MemberMustBePublic implements RuleValidator {
+        public void validate(FrameworkMember<?> member, Class<? extends Annotation> annotation, List<Throwable> errors) {
+            if (!member.isPublic()) {
+                errors.add(new ValidationError(member, annotation,
+                        "must be public."));
+            }
+        }
+    }
+
+    /**
+     * Requires the member is a field implementing {@link org.junit.rules.MethodRule} or {@link org.junit.rules.TestRule}
+     */
+    private static final class FieldMustBeARule implements RuleValidator {
+        public void validate(FrameworkMember<?> member, Class<? extends Annotation> annotation, List<Throwable> errors) {
+            if (!isRuleType(member)) {
+                errors.add(new ValidationError(member, annotation,
+                        "must implement MethodRule or TestRule."));
+            }
+        }
+    }
+
+    /**
+     * Require the member to return an implementation of {@link org.junit.rules.MethodRule} or
+     * {@link org.junit.rules.TestRule}
+     */
+    private static final class MethodMustBeARule implements RuleValidator {
+        public void validate(FrameworkMember<?> member, Class<? extends Annotation> annotation, List<Throwable> errors) {
+            if (!isRuleType(member)) {
+                errors.add(new ValidationError(member, annotation,
+                        "must return an implementation of MethodRule or TestRule."));
+            }
+        }
+    }
+    
+    /**
+     * Require the member to return an implementation of {@link org.junit.rules.TestRule}
+     */
+    private static final class MethodMustBeATestRule implements RuleValidator {
+        public void validate(FrameworkMember<?> member,
+                Class<? extends Annotation> annotation, List<Throwable> errors) {
+            if (!isTestRule(member)) {
+                errors.add(new ValidationError(member, annotation, 
+                        "must return an implementation of TestRule."));
+            }
+        }
+    }
+    
+    /**
+     * Requires the member is a field implementing {@link org.junit.rules.TestRule}
+     */
+    private static final class FieldMustBeATestRule implements RuleValidator {
+
+        public void validate(FrameworkMember<?> member,
+                Class<? extends Annotation> annotation, List<Throwable> errors) {
+            if (!isTestRule(member)) {
+                errors.add(new ValidationError(member, annotation,
+                        "must implement TestRule."));
+            }
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/rules/ValidationError.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/rules/ValidationError.java
new file mode 100644
index 0000000..31bd660
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/rules/ValidationError.java
@@ -0,0 +1,14 @@
+package org.junit.internal.runners.rules;
+
+import org.junit.runners.model.FrameworkMember;
+
+import java.lang.annotation.Annotation;
+
+class ValidationError extends Exception {
+
+    private static final long serialVersionUID = 3176511008672645574L;
+
+    public ValidationError(FrameworkMember<?> member, Class<? extends Annotation> annotation, String suffix) {
+        super(String.format("The @%s '%s' %s", annotation.getSimpleName(), member.getName(), suffix));
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/ExpectException.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/ExpectException.java
new file mode 100644
index 0000000..9a2a952
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/ExpectException.java
@@ -0,0 +1,38 @@
+package org.junit.internal.runners.statements;
+
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runners.model.Statement;
+
+public class ExpectException extends Statement {
+    private final Statement next;
+    private final Class<? extends Throwable> expected;
+
+    public ExpectException(Statement next, Class<? extends Throwable> expected) {
+        this.next = next;
+        this.expected = expected;
+    }
+
+    @Override
+    public void evaluate() throws Exception {
+        boolean complete = false;
+        try {
+            next.evaluate();
+            complete = true;
+        } catch (AssumptionViolatedException e) {
+            if (!expected.isAssignableFrom(e.getClass())) {
+                throw e;
+            }
+        } catch (Throwable e) {
+            if (!expected.isAssignableFrom(e.getClass())) {
+                String message = "Unexpected exception, expected<"
+                        + expected.getName() + "> but was<"
+                        + e.getClass().getName() + ">";
+                throw new Exception(message, e);
+            }
+        }
+        if (complete) {
+            throw new AssertionError("Expected exception: "
+                    + expected.getName());
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/Fail.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/Fail.java
new file mode 100644
index 0000000..e55875c
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/Fail.java
@@ -0,0 +1,16 @@
+package org.junit.internal.runners.statements;
+
+import org.junit.runners.model.Statement;
+
+public class Fail extends Statement {
+    private final Throwable error;
+
+    public Fail(Throwable e) {
+        error = e;
+    }
+
+    @Override
+    public void evaluate() throws Throwable {
+        throw error;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/FailOnTimeout.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/FailOnTimeout.java
new file mode 100644
index 0000000..9362cc1
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/FailOnTimeout.java
@@ -0,0 +1,312 @@
+package org.junit.internal.runners.statements;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.junit.internal.management.ManagementFactory;
+import org.junit.internal.management.ThreadMXBean;
+import org.junit.runners.model.MultipleFailureException;
+import org.junit.runners.model.Statement;
+import org.junit.runners.model.TestTimedOutException;
+
+public class FailOnTimeout extends Statement {
+    private final Statement originalStatement;
+    private final TimeUnit timeUnit;
+    private final long timeout;
+    private final boolean lookForStuckThread;
+
+    /**
+     * Returns a new builder for building an instance.
+     *
+     * @since 4.12
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /**
+     * Creates an instance wrapping the given statement with the given timeout in milliseconds.
+     *
+     * @param statement the statement to wrap
+     * @param timeoutMillis the timeout in milliseconds
+     * @deprecated use {@link #builder()} instead.
+     */
+    @Deprecated
+    public FailOnTimeout(Statement statement, long timeoutMillis) {
+        this(builder().withTimeout(timeoutMillis, TimeUnit.MILLISECONDS), statement);
+    }
+
+    private FailOnTimeout(Builder builder, Statement statement) {
+        originalStatement = statement;
+        timeout = builder.timeout;
+        timeUnit = builder.unit;
+        lookForStuckThread = builder.lookForStuckThread;
+    }
+
+    /**
+     * Builder for {@link FailOnTimeout}.
+     *
+     * @since 4.12
+     */
+    public static class Builder {
+        private boolean lookForStuckThread = false;
+        private long timeout = 0;
+        private TimeUnit unit = TimeUnit.SECONDS;
+
+        private Builder() {
+        }
+
+        /**
+         * Specifies the time to wait before timing out the test.
+         *
+         * <p>If this is not called, or is called with a {@code timeout} of
+         * {@code 0}, the returned {@code Statement} will wait forever for the
+         * test to complete, however the test will still launch from a separate
+         * thread. This can be useful for disabling timeouts in environments
+         * where they are dynamically set based on some property.
+         *
+         * @param timeout the maximum time to wait
+         * @param unit the time unit of the {@code timeout} argument
+         * @return {@code this} for method chaining.
+         */
+        public Builder withTimeout(long timeout, TimeUnit unit) {
+            if (timeout < 0) {
+                throw new IllegalArgumentException("timeout must be non-negative");
+            }
+            if (unit == null) {
+                throw new NullPointerException("TimeUnit cannot be null");
+            }
+            this.timeout = timeout;
+            this.unit = unit;
+            return this;
+        }
+
+        /**
+         * Specifies whether to look for a stuck thread.  If a timeout occurs and this
+         * feature is enabled, the test will look for a thread that appears to be stuck
+         * and dump its backtrace.  This feature is experimental.  Behavior may change
+         * after the 4.12 release in response to feedback.
+         *
+         * @param enable {@code true} to enable the feature
+         * @return {@code this} for method chaining.
+         */
+        public Builder withLookingForStuckThread(boolean enable) {
+            this.lookForStuckThread = enable;
+            return this;
+        }
+
+        /**
+         * Builds a {@link FailOnTimeout} instance using the values in this builder,
+         * wrapping the given statement.
+         *
+         * @param statement
+         */
+        public FailOnTimeout build(Statement statement) {
+            if (statement == null) {
+                throw new NullPointerException("statement cannot be null");
+            }
+            return new FailOnTimeout(this, statement);
+        }
+    }
+
+    @Override
+    public void evaluate() throws Throwable {
+        CallableStatement callable = new CallableStatement();
+        FutureTask<Throwable> task = new FutureTask<Throwable>(callable);
+        ThreadGroup threadGroup = threadGroupForNewThread();
+        Thread thread = new Thread(threadGroup, task, "Time-limited test");
+        thread.setDaemon(true);
+        thread.start();
+        callable.awaitStarted();
+        Throwable throwable = getResult(task, thread);
+        if (throwable != null) {
+            throw throwable;
+        }
+    }
+
+    private ThreadGroup threadGroupForNewThread() {
+        if (!lookForStuckThread) {
+            // Use the default ThreadGroup (usually the one from the current
+            // thread).
+            return null;
+        }
+
+        // Create the thread in a new ThreadGroup, so if the time-limited thread
+        // becomes stuck, getStuckThread() can find the thread likely to be the
+        // culprit.
+        ThreadGroup threadGroup = new ThreadGroup("FailOnTimeoutGroup");
+        if (!threadGroup.isDaemon()) {
+            // Mark the new ThreadGroup as a daemon thread group, so it will be
+            // destroyed after the time-limited thread completes. By ensuring the
+            // ThreadGroup is destroyed, any data associated with the ThreadGroup
+            // (ex: via java.beans.ThreadGroupContext) is destroyed.
+            try {
+                threadGroup.setDaemon(true);
+            } catch (SecurityException e) {
+                // Swallow the exception to keep the same behavior as in JUnit 4.12.
+            }
+        }
+        return threadGroup;
+    }
+
+    /**
+     * Wait for the test task, returning the exception thrown by the test if the
+     * test failed, an exception indicating a timeout if the test timed out, or
+     * {@code null} if the test passed.
+     */
+    private Throwable getResult(FutureTask<Throwable> task, Thread thread) {
+        try {
+            if (timeout > 0) {
+                return task.get(timeout, timeUnit);
+            } else {
+                return task.get();
+            }
+        } catch (InterruptedException e) {
+            return e; // caller will re-throw; no need to call Thread.interrupt()
+        } catch (ExecutionException e) {
+            // test failed; have caller re-throw the exception thrown by the test
+            return e.getCause();
+        } catch (TimeoutException e) {
+            return createTimeoutException(thread);
+        }
+    }
+
+    private Exception createTimeoutException(Thread thread) {
+        StackTraceElement[] stackTrace = thread.getStackTrace();
+        final Thread stuckThread = lookForStuckThread ? getStuckThread(thread) : null;
+        Exception currThreadException = new TestTimedOutException(timeout, timeUnit);
+        if (stackTrace != null) {
+            currThreadException.setStackTrace(stackTrace);
+            thread.interrupt();
+        }
+        if (stuckThread != null) {
+            Exception stuckThreadException = 
+                new Exception("Appears to be stuck in thread " +
+                               stuckThread.getName());
+            stuckThreadException.setStackTrace(getStackTrace(stuckThread));
+            return new MultipleFailureException(
+                Arrays.<Throwable>asList(currThreadException, stuckThreadException));
+        } else {
+            return currThreadException;
+        }
+    }
+
+    /**
+     * Retrieves the stack trace for a given thread.
+     * @param thread The thread whose stack is to be retrieved.
+     * @return The stack trace; returns a zero-length array if the thread has 
+     * terminated or the stack cannot be retrieved for some other reason.
+     */
+    private StackTraceElement[] getStackTrace(Thread thread) {
+        try {
+            return thread.getStackTrace();
+        } catch (SecurityException e) {
+            return new StackTraceElement[0];
+        }
+    }
+
+    /**
+     * Determines whether the test appears to be stuck in some thread other than
+     * the "main thread" (the one created to run the test).  This feature is experimental.
+     * Behavior may change after the 4.12 release in response to feedback.
+     * @param mainThread The main thread created by {@code evaluate()}
+     * @return The thread which appears to be causing the problem, if different from
+     * {@code mainThread}, or {@code null} if the main thread appears to be the
+     * problem or if the thread cannot be determined.  The return value is never equal 
+     * to {@code mainThread}.
+     */
+    private Thread getStuckThread(Thread mainThread) {
+        List<Thread> threadsInGroup = getThreadsInGroup(mainThread.getThreadGroup());
+        if (threadsInGroup.isEmpty()) {
+            return null;
+        }
+
+        // Now that we have all the threads in the test's thread group: Assume that
+        // any thread we're "stuck" in is RUNNABLE.  Look for all RUNNABLE threads. 
+        // If just one, we return that (unless it equals threadMain).  If there's more
+        // than one, pick the one that's using the most CPU time, if this feature is
+        // supported.
+        Thread stuckThread = null;
+        long maxCpuTime = 0;
+        for (Thread thread : threadsInGroup) {
+            if (thread.getState() == Thread.State.RUNNABLE) {
+                long threadCpuTime = cpuTime(thread);
+                if (stuckThread == null || threadCpuTime > maxCpuTime) {
+                    stuckThread = thread;
+                    maxCpuTime = threadCpuTime;
+                }
+            }               
+        }
+        return (stuckThread == mainThread) ? null : stuckThread;
+    }
+
+    /**
+     * Returns all active threads belonging to a thread group.  
+     * @param group The thread group.
+     * @return The active threads in the thread group.  The result should be a
+     * complete list of the active threads at some point in time.  Returns an empty list
+     * if this cannot be determined, e.g. because new threads are being created at an
+     * extremely fast rate.
+     */
+    private List<Thread> getThreadsInGroup(ThreadGroup group) {
+        final int activeThreadCount = group.activeCount(); // this is just an estimate
+        int threadArraySize = Math.max(activeThreadCount * 2, 100);
+        for (int loopCount = 0; loopCount < 5; loopCount++) {
+            Thread[] threads = new Thread[threadArraySize];
+            int enumCount = group.enumerate(threads);
+            if (enumCount < threadArraySize) {
+                return Arrays.asList(threads).subList(0, enumCount);
+            }
+            // if there are too many threads to fit into the array, enumerate's result
+            // is >= the array's length; therefore we can't trust that it returned all
+            // the threads.  Try again.
+            threadArraySize += 100;
+        }
+        // threads are proliferating too fast for us.  Bail before we get into 
+        // trouble.
+        return Collections.emptyList();
+    }
+
+    /**
+     * Returns the CPU time used by a thread, if possible.
+     * @param thr The thread to query.
+     * @return The CPU time used by {@code thr}, or 0 if it cannot be determined.
+     */
+    private long cpuTime(Thread thr) {
+        ThreadMXBean mxBean = ManagementFactory.getThreadMXBean();
+        if (mxBean.isThreadCpuTimeSupported()) {
+            try {
+                return mxBean.getThreadCpuTime(thr.getId());
+            } catch (UnsupportedOperationException e) {
+            }
+        }
+        return 0;
+    }
+
+    private class CallableStatement implements Callable<Throwable> {
+        private final CountDownLatch startLatch = new CountDownLatch(1);
+
+        public Throwable call() throws Exception {
+            try {
+                startLatch.countDown();
+                originalStatement.evaluate();
+            } catch (Exception e) {
+                throw e;
+            } catch (Throwable e) {
+                return e;
+            }
+            return null;
+        }
+
+        public void awaitStarted() throws InterruptedException {
+            startLatch.await();
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/InvokeMethod.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/InvokeMethod.java
new file mode 100644
index 0000000..68c0545
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/InvokeMethod.java
@@ -0,0 +1,19 @@
+package org.junit.internal.runners.statements;
+
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+public class InvokeMethod extends Statement {
+    private final FrameworkMethod testMethod;
+    private final Object target;
+
+    public InvokeMethod(FrameworkMethod testMethod, Object target) {
+        this.testMethod = testMethod;
+        this.target = target;
+    }
+
+    @Override
+    public void evaluate() throws Throwable {
+        testMethod.invokeExplosively(target);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/RunAfters.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/RunAfters.java
new file mode 100644
index 0000000..5e56c33
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/RunAfters.java
@@ -0,0 +1,48 @@
+package org.junit.internal.runners.statements;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.MultipleFailureException;
+import org.junit.runners.model.Statement;
+
+public class RunAfters extends Statement {
+    private final Statement next;
+
+    private final Object target;
+
+    private final List<FrameworkMethod> afters;
+
+    public RunAfters(Statement next, List<FrameworkMethod> afters, Object target) {
+        this.next = next;
+        this.afters = afters;
+        this.target = target;
+    }
+
+    @Override
+    public void evaluate() throws Throwable {
+        List<Throwable> errors = new ArrayList<Throwable>();
+        try {
+            next.evaluate();
+        } catch (Throwable e) {
+            errors.add(e);
+        } finally {
+            for (FrameworkMethod each : afters) {
+                try {
+                    invokeMethod(each);
+                } catch (Throwable e) {
+                    errors.add(e);
+                }
+            }
+        }
+        MultipleFailureException.assertEmpty(errors);
+    }
+
+    /**
+     * @since 4.13
+     */
+    protected void invokeMethod(FrameworkMethod method) throws Throwable {
+        method.invokeExplosively(target);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/RunBefores.java b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/RunBefores.java
new file mode 100644
index 0000000..bd835c7
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/internal/runners/statements/RunBefores.java
@@ -0,0 +1,35 @@
+package org.junit.internal.runners.statements;
+
+import java.util.List;
+
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+public class RunBefores extends Statement {
+    private final Statement next;
+
+    private final Object target;
+
+    private final List<FrameworkMethod> befores;
+
+    public RunBefores(Statement next, List<FrameworkMethod> befores, Object target) {
+        this.next = next;
+        this.befores = befores;
+        this.target = target;
+    }
+
+    @Override
+    public void evaluate() throws Throwable {
+        for (FrameworkMethod before : befores) {
+            invokeMethod(before);
+        }
+        next.evaluate();
+    }
+
+    /**
+     * @since 4.13
+     */
+    protected void invokeMethod(FrameworkMethod method) throws Throwable {
+        method.invokeExplosively(target);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/matchers/JUnitMatchers.java b/google3/third_party/java_src/junit/main/java/org/junit/matchers/JUnitMatchers.java
new file mode 100644
index 0000000..13407cc
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/matchers/JUnitMatchers.java
@@ -0,0 +1,113 @@
+package org.junit.matchers;
+
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.Matcher;
+import org.hamcrest.core.CombinableMatcher.CombinableBothMatcher;
+import org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher;
+import org.junit.internal.matchers.StacktracePrintingMatcher;
+
+/**
+ * Convenience import class: these are useful matchers for use with the assertThat method, but they are
+ * not currently included in the basic CoreMatchers class from hamcrest.
+ *
+ * @since 4.4
+ */
+public class JUnitMatchers {
+    /**
+     * @return A matcher matching any collection containing element
+     * @deprecated Please use {@link CoreMatchers#hasItem(Object)} instead.
+     */
+    @Deprecated
+    public static <T> Matcher<Iterable<? super T>> hasItem(T element) {
+        return CoreMatchers.hasItem(element);
+    }
+
+    /**
+     * @return A matcher matching any collection containing an element matching elementMatcher
+     * @deprecated Please use {@link CoreMatchers#hasItem(Matcher)} instead.
+     */
+    @Deprecated
+    public static <T> Matcher<Iterable<? super T>> hasItem(Matcher<? super T> elementMatcher) {
+        return CoreMatchers.<T>hasItem(elementMatcher);
+    }
+
+    /**
+     * @return A matcher matching any collection containing every element in elements
+     * @deprecated Please use {@link CoreMatchers#hasItems(Object...)} instead.
+     */
+    @Deprecated
+    public static <T> Matcher<Iterable<T>> hasItems(T... elements) {
+        return CoreMatchers.hasItems(elements);
+    }
+
+    /**
+     * @return A matcher matching any collection containing at least one element that matches
+     *         each matcher in elementMatcher (this may be one element matching all matchers,
+     *         or different elements matching each matcher)
+     * @deprecated Please use {@link CoreMatchers#hasItems(Matcher...)} instead.
+     */
+    @Deprecated
+    public static <T> Matcher<Iterable<T>> hasItems(Matcher<? super T>... elementMatchers) {
+        return CoreMatchers.hasItems(elementMatchers);
+    }
+
+    /**
+     * @return A matcher matching any collection in which every element matches elementMatcher
+     * @deprecated Please use {@link CoreMatchers#everyItem(Matcher)} instead.
+     */
+    @Deprecated
+    public static <T> Matcher<Iterable<T>> everyItem(final Matcher<T> elementMatcher) {
+        return CoreMatchers.everyItem(elementMatcher);
+    }
+
+    /**
+     * @return a matcher matching any string that contains substring
+     * @deprecated Please use {@link CoreMatchers#containsString(String)} instead.
+     */
+    @Deprecated
+    public static Matcher<java.lang.String> containsString(java.lang.String substring) {
+        return CoreMatchers.containsString(substring);
+    }
+
+    /**
+     * This is useful for fluently combining matchers that must both pass.  For example:
+     * <pre>
+     *   assertThat(string, both(containsString("a")).and(containsString("b")));
+     * </pre>
+     *
+     * @deprecated Please use {@link CoreMatchers#both(Matcher)} instead.
+     */
+    @Deprecated
+    public static <T> CombinableBothMatcher<T> both(Matcher<? super T> matcher) {
+        return CoreMatchers.both(matcher);
+    }
+
+    /**
+     * This is useful for fluently combining matchers where either may pass, for example:
+     * <pre>
+     *   assertThat(string, either(containsString("a")).or(containsString("b")));
+     * </pre>
+     *
+     * @deprecated Please use {@link CoreMatchers#either(Matcher)} instead.
+     */
+    @Deprecated
+    public static <T> CombinableEitherMatcher<T> either(Matcher<? super T> matcher) {
+        return CoreMatchers.either(matcher);
+    }
+
+    /**
+     * @return A matcher that delegates to throwableMatcher and in addition
+     *         appends the stacktrace of the actual Throwable in case of a mismatch.
+     */
+    public static <T extends Throwable> Matcher<T> isThrowable(Matcher<T> throwableMatcher) {
+        return StacktracePrintingMatcher.isThrowable(throwableMatcher);
+    }
+
+    /**
+     * @return A matcher that delegates to exceptionMatcher and in addition
+     *         appends the stacktrace of the actual Exception in case of a mismatch.
+     */
+    public static <T extends Exception> Matcher<T> isException(Matcher<T> exceptionMatcher) {
+        return StacktracePrintingMatcher.isException(exceptionMatcher);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/matchers/package-info.java b/google3/third_party/java_src/junit/main/java/org/junit/matchers/package-info.java
new file mode 100644
index 0000000..71aca34
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/matchers/package-info.java
@@ -0,0 +1,9 @@
+/**
+ * Provides useful additional {@link org.hamcrest.Matcher}s for use with
+ * the {@link org.junit.Assert#assertThat(Object, org.hamcrest.Matcher)}
+ * statement
+ *
+ * @since 4.0
+ * @see org.junit.matchers.JUnitMatchers
+ */
+package org.junit.matchers;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/package-info.java b/google3/third_party/java_src/junit/main/java/org/junit/package-info.java
new file mode 100644
index 0000000..fb12f25
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/package-info.java
@@ -0,0 +1,8 @@
+/**
+ * Provides JUnit core classes and annotations. 
+ *
+ * Corresponds to junit.framework in Junit 3.x.
+ *
+ * @since 4.0
+ */
+package org.junit;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/DisableOnDebug.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/DisableOnDebug.java
new file mode 100644
index 0000000..3bca103
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/DisableOnDebug.java
@@ -0,0 +1,125 @@
+package org.junit.rules;
+
+import java.util.List;
+
+import org.junit.internal.management.ManagementFactory;
+import org.junit.internal.management.RuntimeMXBean;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * The {@code DisableOnDebug} Rule allows you to label certain rules to be
+ * disabled when debugging.
+ * <p>
+ * The most illustrative use case is for tests that make use of the
+ * {@link Timeout} rule, when ran in debug mode the test may terminate on
+ * timeout abruptly during debugging. Developers may disable the timeout, or
+ * increase the timeout by making a code change on tests that need debugging and
+ * remember revert the change afterwards or rules such as {@link Timeout} that
+ * may be disabled during debugging may be wrapped in a {@code DisableOnDebug}.
+ * <p>
+ * The important benefit of this feature is that you can disable such rules
+ * without any making any modifications to your test class to remove them during
+ * debugging.
+ * <p>
+ * This does nothing to tackle timeouts or time sensitive code under test when
+ * debugging and may make this less useful in such circumstances.
+ * <p>
+ * Example usage:
+ * 
+ * <pre>
+ * public static class DisableTimeoutOnDebugSampleTest {
+ * 
+ *     &#064;Rule
+ *     public TestRule timeout = new DisableOnDebug(new Timeout(20));
+ * 
+ *     &#064;Test
+ *     public void myTest() {
+ *         int i = 0;
+ *         assertEquals(0, i); // suppose you had a break point here to inspect i
+ *     }
+ * }
+ * </pre>
+ * 
+ * @since 4.12
+ */
+public class DisableOnDebug implements TestRule {
+    private final TestRule rule;
+    private final boolean debugging;
+
+    /**
+     * Create a {@code DisableOnDebug} instance with the timeout specified in
+     * milliseconds.
+     * 
+     * @param rule to disable during debugging
+     */
+    public DisableOnDebug(TestRule rule) {
+        this(rule, ManagementFactory.getRuntimeMXBean()
+                .getInputArguments());
+    }
+
+    /**
+     * Visible for testing purposes only.
+     * 
+     * @param rule the rule to disable during debugging
+     * @param inputArguments
+     *            arguments provided to the Java runtime
+     */
+    DisableOnDebug(TestRule rule, List<String> inputArguments) {
+        this.rule = rule;
+        debugging = isDebugging(inputArguments);
+    }
+
+    /**
+     * @see TestRule#apply(Statement, Description)
+     */
+    public Statement apply(Statement base, Description description) {
+        if (debugging) {
+            return base;
+        } else {
+            return rule.apply(base, description);
+        }
+    }
+
+    /**
+     * Parses arguments passed to the runtime environment for debug flags
+     * <p>
+     * Options specified in:
+     * <ul>
+     * <li>
+     * <a href="http://docs.oracle.com/javase/6/docs/technotes/guides/jpda/conninv.html#Invocation"
+     * >javase-6</a></li>
+     * <li><a href="http://docs.oracle.com/javase/7/docs/technotes/guides/jpda/conninv.html#Invocation"
+     * >javase-7</a></li>
+     * <li><a href="http://docs.oracle.com/javase/8/docs/technotes/guides/jpda/conninv.html#Invocation"
+     * >javase-8</a></li>
+     * 
+     * 
+     * @param arguments
+     *            the arguments passed to the runtime environment, usually this
+     *            will be {@link RuntimeMXBean#getInputArguments()}
+     * @return true if the current JVM was started in debug mode, false
+     *         otherwise.
+     */
+    private static boolean isDebugging(List<String> arguments) {
+        for (final String argument : arguments) {
+            if ("-Xdebug".equals(argument) || argument.startsWith("-agentlib:jdwp")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Returns {@code true} if the JVM is in debug mode. This method may be used
+     * by test classes to take additional action to disable code paths that
+     * interfere with debugging if required.
+     * 
+     * @return {@code true} if the current JVM is in debug mode, {@code false}
+     *         otherwise
+     */
+    public boolean isDebugging() {
+        return debugging;
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/ErrorCollector.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/ErrorCollector.java
new file mode 100644
index 0000000..9711e50
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/ErrorCollector.java
@@ -0,0 +1,120 @@
+package org.junit.rules;
+
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+import org.junit.function.ThrowingRunnable;
+import org.junit.internal.AssumptionViolatedException;
+import org.hamcrest.Matcher;
+import org.junit.runners.model.MultipleFailureException;
+
+/**
+ * The ErrorCollector rule allows execution of a test to continue after the
+ * first problem is found (for example, to collect _all_ the incorrect rows in a
+ * table, and report them all at once):
+ *
+ * <pre>
+ * public static class UsesErrorCollectorTwice {
+ * 	&#064;Rule
+ * 	public ErrorCollector collector= new ErrorCollector();
+ *
+ * &#064;Test
+ * public void example() {
+ *      collector.addError(new Throwable(&quot;first thing went wrong&quot;));
+ *      collector.addError(new Throwable(&quot;second thing went wrong&quot;));
+ *      collector.checkThat(getResult(), not(containsString(&quot;ERROR!&quot;)));
+ *      // all lines will run, and then a combined failure logged at the end.
+ *     }
+ * }
+ * </pre>
+ *
+ * @since 4.7
+ */
+public class ErrorCollector extends Verifier {
+    private List<Throwable> errors = new ArrayList<Throwable>();
+
+    @Override
+    protected void verify() throws Throwable {
+        MultipleFailureException.assertEmpty(errors);
+    }
+
+    /**
+     * Adds a Throwable to the table.  Execution continues, but the test will fail at the end.
+     */
+    public void addError(Throwable error) {
+        if (error == null) {
+            throw new NullPointerException("Error cannot be null");
+        }
+        if (error instanceof AssumptionViolatedException) {
+            AssertionError e = new AssertionError(error.getMessage());
+            e.initCause(error);
+            errors.add(e);
+        } else {
+            errors.add(error);
+        }
+    }
+
+    /**
+     * Adds a failure to the table if {@code matcher} does not match {@code value}.
+     * Execution continues, but the test will fail at the end if the match fails.
+     */
+    public <T> void checkThat(final T value, final Matcher<T> matcher) {
+        checkThat("", value, matcher);
+    }
+
+    /**
+     * Adds a failure with the given {@code reason}
+     * to the table if {@code matcher} does not match {@code value}.
+     * Execution continues, but the test will fail at the end if the match fails.
+     */
+    public <T> void checkThat(final String reason, final T value, final Matcher<T> matcher) {
+        checkSucceeds(new Callable<Object>() {
+            public Object call() throws Exception {
+                assertThat(reason, value, matcher);
+                return value;
+            }
+        });
+    }
+
+    /**
+     * Adds to the table the exception, if any, thrown from {@code callable}.
+     * Execution continues, but the test will fail at the end if
+     * {@code callable} threw an exception.
+     */
+    public <T> T checkSucceeds(Callable<T> callable) {
+        try {
+            return callable.call();
+        } catch (AssumptionViolatedException e) {
+            AssertionError error = new AssertionError("Callable threw AssumptionViolatedException");
+            error.initCause(e);
+            addError(error);
+            return null;
+        } catch (Throwable e) {
+            addError(e);
+            return null;
+        }
+    }
+
+    /**
+     * Adds a failure to the table if {@code runnable} does not throw an
+     * exception of type {@code expectedThrowable} when executed.
+     * Execution continues, but the test will fail at the end if the runnable
+     * does not throw an exception, or if it throws a different exception.
+     *
+     * @param expectedThrowable the expected type of the exception
+     * @param runnable       a function that is expected to throw an exception when executed
+     * @since 4.13
+     */
+    public void checkThrows(Class<? extends Throwable> expectedThrowable, ThrowingRunnable runnable) {
+        try {
+            assertThrows(expectedThrowable, runnable);
+        } catch (AssertionError e) {
+            addError(e);
+        }
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/ExpectedException.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/ExpectedException.java
new file mode 100644
index 0000000..431ad49
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/ExpectedException.java
@@ -0,0 +1,285 @@
+package org.junit.rules;
+
+import static java.lang.String.format;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import static org.junit.internal.matchers.ThrowableCauseMatcher.hasCause;
+import static org.junit.internal.matchers.ThrowableMessageMatcher.hasMessage;
+import org.hamcrest.Matcher;
+import org.hamcrest.StringDescription;
+import org.junit.AssumptionViolatedException;
+import org.junit.runners.model.Statement;
+
+/**
+ * The {@code ExpectedException} rule allows you to verify that your code
+ * throws a specific exception.
+ *
+ * <h3>Usage</h3>
+ *
+ * <pre> public class SimpleExpectedExceptionTest {
+ *     &#064;Rule
+ *     public ExpectedException thrown = ExpectedException.none();
+ *
+ *     &#064;Test
+ *     public void throwsNothing() {
+ *         // no exception expected, none thrown: passes.
+ *     }
+ *
+ *     &#064;Test
+ *     public void throwsExceptionWithSpecificType() {
+ *         thrown.expect(NullPointerException.class);
+ *         throw new NullPointerException();
+ *     }
+ * }</pre>
+ * 
+ * <p>You have to add the {@code ExpectedException} rule to your test.
+ * This doesn't affect your existing tests (see {@code throwsNothing()}).
+ * After specifying the type of the expected exception your test is
+ * successful when such an exception is thrown and it fails if a
+ * different or no exception is thrown.
+ *
+ * <p>This rule does not perform any special magic to make execution continue
+ * as if the exception had not been thrown. So it is nearly always a mistake
+ * for a test method to have statements after the one that is expected to
+ * throw the exception.
+ *
+ * <p>Instead of specifying the exception's type you can characterize the
+ * expected exception based on other criteria, too:
+ *
+ * <ul>
+ *   <li>The exception's message contains a specific text: {@link #expectMessage(String)}</li>
+ *   <li>The exception's message complies with a Hamcrest matcher: {@link #expectMessage(Matcher)}</li>
+ *   <li>The exception's cause complies with a Hamcrest matcher: {@link #expectCause(Matcher)}</li>
+ *   <li>The exception itself complies with a Hamcrest matcher: {@link #expect(Matcher)}</li>
+ * </ul>
+ *
+ * <p>You can combine any of the presented expect-methods. The test is
+ * successful if all specifications are met.
+ * <pre> &#064;Test
+ * public void throwsException() {
+ *     thrown.expect(NullPointerException.class);
+ *     thrown.expectMessage(&quot;happened&quot;);
+ *     throw new NullPointerException(&quot;What happened?&quot;);
+ * }</pre>
+ *
+ * <p>It is recommended to set the {@link org.junit.Rule#order() order} of the
+ * {@code ExpectedException} to {@code Integer.MAX_VALUE} if it is used together
+ * with another rule that handles exceptions, e.g. {@link ErrorCollector}.
+ * Otherwise failing tests may be successful.
+ * <pre> &#064;Rule(order = Integer.MAX_VALUE)
+ * public ExpectedException thrown = ExpectedException.none();</pre>
+ *
+ * <h3>AssumptionViolatedExceptions</h3>
+ * <p>JUnit uses {@link AssumptionViolatedException}s for indicating that a test
+ * provides no useful information. (See {@link org.junit.Assume} for more
+ * information.) You have to call {@code assume} methods before you set
+ * expectations of the {@code ExpectedException} rule. In this case the rule
+ * will not handle consume the exceptions and it can be handled by the
+ * framework. E.g. the following test is ignored by JUnit's default runner.
+ *
+ * <pre> &#064;Test
+ * public void ignoredBecauseOfFailedAssumption() {
+ *     assumeTrue(false); // throws AssumptionViolatedException
+ *     thrown.expect(NullPointerException.class);
+ * }</pre>
+ *
+ * <h3>AssertionErrors</h3>
+ *
+ * <p>JUnit uses {@link AssertionError}s for indicating that a test is failing. You
+ * have to call {@code assert} methods before you set expectations of the
+ * {@code ExpectedException} rule, if they should be handled by the framework.
+ * E.g. the following test fails because of the {@code assertTrue} statement.
+ *
+ * <pre> &#064;Test
+ * public void throwsUnhandled() {
+ *     assertTrue(false); // throws AssertionError
+ *     thrown.expect(NullPointerException.class);
+ * }</pre>
+ *
+ * <h3>Missing Exceptions</h3>
+ * <p>By default missing exceptions are reported with an error message
+ * like "Expected test to throw an instance of foo". You can configure a different
+ * message by means of {@link #reportMissingExceptionWithMessage(String)}. You
+ * can use a {@code %s} placeholder for the description of the expected
+ * exception. E.g. "Test doesn't throw %s." will fail with the error message
+ * "Test doesn't throw an instance of foo.".
+ *
+ * @since 4.7
+ */
+public class ExpectedException implements TestRule {
+    /**
+     * Returns a {@linkplain TestRule rule} that expects no exception to
+     * be thrown (identical to behavior without this rule).
+     *
+     * @deprecated Since 4.13
+     * {@link org.junit.Assert#assertThrows(Class, org.junit.function.ThrowingRunnable)
+     * Assert.assertThrows} can be used to verify that your code throws a specific
+     * exception.
+     */
+    @Deprecated
+    public static ExpectedException none() {
+        return new ExpectedException();
+    }
+
+    private final ExpectedExceptionMatcherBuilder matcherBuilder = new ExpectedExceptionMatcherBuilder();
+
+    private String missingExceptionMessage= "Expected test to throw %s";
+
+    private ExpectedException() {
+    }
+
+    /**
+     * This method does nothing. Don't use it.
+     * @deprecated AssertionErrors are handled by default since JUnit 4.12. Just
+     *             like in JUnit &lt;= 4.10.
+     */
+    @Deprecated
+    public ExpectedException handleAssertionErrors() {
+        return this;
+    }
+
+    /**
+     * This method does nothing. Don't use it.
+     * @deprecated AssumptionViolatedExceptions are handled by default since
+     *             JUnit 4.12. Just like in JUnit &lt;= 4.10.
+     */
+    @Deprecated
+    public ExpectedException handleAssumptionViolatedExceptions() {
+        return this;
+    }
+
+    /**
+     * Specifies the failure message for tests that are expected to throw 
+     * an exception but do not throw any. You can use a {@code %s} placeholder for
+     * the description of the expected exception. E.g. "Test doesn't throw %s."
+     * will fail with the error message
+     * "Test doesn't throw an instance of foo.".
+     *
+     * @param message exception detail message
+     * @return the rule itself
+     */
+    public ExpectedException reportMissingExceptionWithMessage(String message) {
+        missingExceptionMessage = message;
+        return this;
+    }
+
+    public Statement apply(Statement base,
+            org.junit.runner.Description description) {
+        return new ExpectedExceptionStatement(base);
+    }
+
+    /**
+     * Verify that your code throws an exception that is matched by
+     * a Hamcrest matcher.
+     * <pre> &#064;Test
+     * public void throwsExceptionThatCompliesWithMatcher() {
+     *     NullPointerException e = new NullPointerException();
+     *     thrown.expect(is(e));
+     *     throw e;
+     * }</pre>
+     */
+    public void expect(Matcher<?> matcher) {
+        matcherBuilder.add(matcher);
+    }
+
+    /**
+     * Verify that your code throws an exception that is an
+     * instance of specific {@code type}.
+     * <pre> &#064;Test
+     * public void throwsExceptionWithSpecificType() {
+     *     thrown.expect(NullPointerException.class);
+     *     throw new NullPointerException();
+     * }</pre>
+     */
+    public void expect(Class<? extends Throwable> type) {
+        expect(instanceOf(type));
+    }
+
+    /**
+     * Verify that your code throws an exception whose message contains
+     * a specific text.
+     * <pre> &#064;Test
+     * public void throwsExceptionWhoseMessageContainsSpecificText() {
+     *     thrown.expectMessage(&quot;happened&quot;);
+     *     throw new NullPointerException(&quot;What happened?&quot;);
+     * }</pre>
+     */
+    public void expectMessage(String substring) {
+        expectMessage(containsString(substring));
+    }
+
+    /**
+     * Verify that your code throws an exception whose message is matched 
+     * by a Hamcrest matcher.
+     * <pre> &#064;Test
+     * public void throwsExceptionWhoseMessageCompliesWithMatcher() {
+     *     thrown.expectMessage(startsWith(&quot;What&quot;));
+     *     throw new NullPointerException(&quot;What happened?&quot;);
+     * }</pre>
+     */
+    public void expectMessage(Matcher<String> matcher) {
+        expect(hasMessage(matcher));
+    }
+
+    /**
+     * Verify that your code throws an exception whose cause is matched by 
+     * a Hamcrest matcher.
+     * <pre> &#064;Test
+     * public void throwsExceptionWhoseCauseCompliesWithMatcher() {
+     *     NullPointerException expectedCause = new NullPointerException();
+     *     thrown.expectCause(is(expectedCause));
+     *     throw new IllegalArgumentException(&quot;What happened?&quot;, cause);
+     * }</pre>
+     */
+    public void expectCause(Matcher<?> expectedCause) {
+        expect(hasCause(expectedCause));
+    }
+
+    /**
+     * Check if any Exception is expected.
+     * @since 4.13
+     */
+    public final boolean isAnyExceptionExpected() {
+        return matcherBuilder.expectsThrowable();
+    }
+
+    private class ExpectedExceptionStatement extends Statement {
+        private final Statement next;
+
+        public ExpectedExceptionStatement(Statement base) {
+            next = base;
+        }
+
+        @Override
+        public void evaluate() throws Throwable {
+            try {
+                next.evaluate();
+            } catch (Throwable e) {
+                handleException(e);
+                return;
+            }
+            if (isAnyExceptionExpected()) {
+                failDueToMissingException();
+            }
+        }
+    }
+
+    private void handleException(Throwable e) throws Throwable {
+        if (isAnyExceptionExpected()) {
+            assertThat(e, matcherBuilder.build());
+        } else {
+            throw e;
+        }
+    }
+
+    private void failDueToMissingException() throws AssertionError {
+        fail(missingExceptionMessage());
+    }
+    
+    private String missingExceptionMessage() {
+        String expectation= StringDescription.toString(matcherBuilder.build());
+        return format(missingExceptionMessage, expectation);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/ExpectedExceptionMatcherBuilder.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/ExpectedExceptionMatcherBuilder.java
new file mode 100644
index 0000000..e7d94c4
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/ExpectedExceptionMatcherBuilder.java
@@ -0,0 +1,46 @@
+package org.junit.rules;
+
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.junit.matchers.JUnitMatchers.isThrowable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.hamcrest.Matcher;
+
+/**
+ * Builds special matcher used by {@link ExpectedException}.
+ */
+class ExpectedExceptionMatcherBuilder {
+
+    private final List<Matcher<?>> matchers = new ArrayList<Matcher<?>>();
+
+    void add(Matcher<?> matcher) {
+        matchers.add(matcher);
+    }
+
+    boolean expectsThrowable() {
+        return !matchers.isEmpty();
+    }
+
+    Matcher<Throwable> build() {
+        return isThrowable(allOfTheMatchers());
+    }
+
+    private Matcher<Throwable> allOfTheMatchers() {
+        if (matchers.size() == 1) {
+            return cast(matchers.get(0));
+        }
+        return allOf(castedMatchers());
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private List<Matcher<? super Throwable>> castedMatchers() {
+        return new ArrayList<Matcher<? super Throwable>>((List) matchers);
+    }
+
+    @SuppressWarnings("unchecked")
+    private Matcher<Throwable> cast(Matcher<?> singleMatcher) {
+        return (Matcher<Throwable>) singleMatcher;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/ExternalResource.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/ExternalResource.java
new file mode 100644
index 0000000..71fc842
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/ExternalResource.java
@@ -0,0 +1,84 @@
+package org.junit.rules;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.runner.Description;
+import org.junit.runners.model.MultipleFailureException;
+import org.junit.runners.model.Statement;
+
+/**
+ * A base class for Rules (like TemporaryFolder) that set up an external
+ * resource before a test (a file, socket, server, database connection, etc.),
+ * and guarantee to tear it down afterward:
+ *
+ * <pre>
+ * public static class UsesExternalResource {
+ *  Server myServer= new Server();
+ *
+ *  &#064;Rule
+ *  public ExternalResource resource= new ExternalResource() {
+ *      &#064;Override
+ *      protected void before() throws Throwable {
+ *          myServer.connect();
+ *         };
+ *
+ *      &#064;Override
+ *      protected void after() {
+ *          myServer.disconnect();
+ *         };
+ *     };
+ *
+ *  &#064;Test
+ *  public void testFoo() {
+ *      new Client().run(myServer);
+ *     }
+ * }
+ * </pre>
+ *
+ * @since 4.7
+ */
+public abstract class ExternalResource implements TestRule {
+    public Statement apply(Statement base, Description description) {
+        return statement(base);
+    }
+
+    private Statement statement(final Statement base) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                before();
+
+                List<Throwable> errors = new ArrayList<Throwable>();
+                try {
+                    base.evaluate();
+                } catch (Throwable t) {
+                    errors.add(t);
+                } finally {
+                    try {
+                        after();
+                    } catch (Throwable t) {
+                        errors.add(t);
+                    }
+                }
+                MultipleFailureException.assertEmpty(errors);
+            }
+        };
+    }
+
+    /**
+     * Override to set up your specific external resource.
+     *
+     * @throws Throwable if setup fails (which will disable {@code after}
+     */
+    protected void before() throws Throwable {
+        // do nothing
+    }
+
+    /**
+     * Override to tear down your specific external resource.
+     */
+    protected void after() {
+        // do nothing
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/MethodRule.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/MethodRule.java
new file mode 100644
index 0000000..94608f5
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/MethodRule.java
@@ -0,0 +1,32 @@
+package org.junit.rules;
+
+import org.junit.Rule;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+/**
+ * A MethodRule is an alteration in how a test method is run and reported.
+ * Multiple {@link MethodRule}s can be applied to a test method. The
+ * {@link Statement} that executes the method is passed to each annotated
+ * {@link Rule} in turn, and each may return a substitute or modified
+ * {@link Statement}, which is passed to the next {@link Rule}, if any. For
+ * an example of how this can be useful, see {@link TestWatchman}.
+ *
+ * <p>Note that {@link MethodRule} has been replaced by {@link TestRule},
+ * which has the added benefit of supporting class rules.
+ *
+ * @since 4.7
+ */
+public interface MethodRule {
+    /**
+     * Modifies the method-running {@link Statement} to implement an additional
+     * test-running rule.
+     *
+     * @param base The {@link Statement} to be modified
+     * @param method The method to be run
+     * @param target The object on which the method will be run.
+     * @return a new statement, which may be the same as {@code base},
+     *         a wrapper around {@code base}, or a completely new Statement.
+     */
+    Statement apply(Statement base, FrameworkMethod method, Object target);
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/RuleChain.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/RuleChain.java
new file mode 100644
index 0000000..bf93aae
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/RuleChain.java
@@ -0,0 +1,113 @@
+package org.junit.rules;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * The {@code RuleChain} can be used for creating composite rules. You create a
+ * {@code RuleChain} with {@link #outerRule(TestRule)} and subsequent calls of
+ * {@link #around(TestRule)}:
+ *
+ * <pre>
+ * public abstract class CompositeRules {
+ *   public static TestRule extendedLogging() {
+ *     return RuleChain.outerRule(new LoggingRule("outer rule"))
+ *                     .around(new LoggingRule("middle rule"))
+ *                     .around(new LoggingRule("inner rule"));
+ *   }
+ * }
+ * </pre>
+ *
+ * <pre>
+ * public class UseRuleChain {
+ *   &#064;Rule
+ *   public final TestRule extendedLogging = CompositeRules.extendedLogging();
+ *
+ *   &#064;Test
+ *   public void example() {
+ *     assertTrue(true);
+ *   }
+ * }
+ * </pre>
+ *
+ * writes the log
+ *
+ * <pre>
+ * starting outer rule
+ * starting middle rule
+ * starting inner rule
+ * finished inner rule
+ * finished middle rule
+ * finished outer rule
+ * </pre>
+ *
+ * In older versions of JUnit (before 4.13) {@code RuleChain} was used for
+ * ordering rules. We recommend to not use it for this purpose anymore. You can
+ * use the attribute {@code order} of the annotation {@link Rule#order() Rule}
+ * or {@link org.junit.ClassRule#order() ClassRule} for ordering rules.
+ *
+ * @see org.junit.Rule#order()
+ * @see org.junit.ClassRule#order()
+ * @since 4.10
+ */
+public class RuleChain implements TestRule {
+    private static final RuleChain EMPTY_CHAIN = new RuleChain(
+            Collections.<TestRule>emptyList());
+
+    private List<TestRule> rulesStartingWithInnerMost;
+
+    /**
+     * Returns a {@code RuleChain} without a {@link TestRule}. This method may
+     * be the starting point of a {@code RuleChain}.
+     *
+     * @return a {@code RuleChain} without a {@link TestRule}.
+     */
+    public static RuleChain emptyRuleChain() {
+        return EMPTY_CHAIN;
+    }
+
+    /**
+     * Returns a {@code RuleChain} with a single {@link TestRule}. This method
+     * is the usual starting point of a {@code RuleChain}.
+     *
+     * @param outerRule the outer rule of the {@code RuleChain}.
+     * @return a {@code RuleChain} with a single {@link TestRule}.
+     */
+    public static RuleChain outerRule(TestRule outerRule) {
+        return emptyRuleChain().around(outerRule);
+    }
+
+    private RuleChain(List<TestRule> rules) {
+        this.rulesStartingWithInnerMost = rules;
+    }
+
+    /**
+     * Create a new {@code RuleChain}, which encloses the given {@link TestRule} with
+     * the rules of the current {@code RuleChain}.
+     *
+     * @param enclosedRule the rule to enclose; must not be {@code null}.
+     * @return a new {@code RuleChain}.
+     * @throws NullPointerException if the argument {@code enclosedRule} is {@code null}
+     */
+    public RuleChain around(TestRule enclosedRule) {
+        if (enclosedRule == null) {
+            throw new NullPointerException("The enclosed rule must not be null");
+        }
+        List<TestRule> rulesOfNewChain = new ArrayList<TestRule>();
+        rulesOfNewChain.add(enclosedRule);
+        rulesOfNewChain.addAll(rulesStartingWithInnerMost);
+        return new RuleChain(rulesOfNewChain);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public Statement apply(Statement base, Description description) {
+        return new RunRules(base, rulesStartingWithInnerMost, description);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/RunRules.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/RunRules.java
new file mode 100644
index 0000000..131fc1f
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/RunRules.java
@@ -0,0 +1,30 @@
+package org.junit.rules;
+
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * Runs a collection of rules on a statement.
+ *
+ * @since 4.9
+ */
+public class RunRules extends Statement {
+    private final Statement statement;
+
+    public RunRules(Statement base, Iterable<TestRule> rules, Description description) {
+        statement = applyAll(base, rules, description);
+    }
+
+    @Override
+    public void evaluate() throws Throwable {
+        statement.evaluate();
+    }
+
+    private static Statement applyAll(Statement result, Iterable<TestRule> rules,
+            Description description) {
+        for (TestRule each : rules) {
+            result = each.apply(result, description);
+        }
+        return result;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/Stopwatch.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/Stopwatch.java
new file mode 100644
index 0000000..6900a48
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/Stopwatch.java
@@ -0,0 +1,183 @@
+package org.junit.rules;
+
+import org.junit.AssumptionViolatedException;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * The Stopwatch Rule notifies one of its own protected methods of the time spent by a test.
+ *
+ * <p>Override them to get the time in nanoseconds. For example, this class will keep logging the
+ * time spent by each passed, failed, skipped, and finished test:
+ *
+ * <pre>
+ * public static class StopwatchTest {
+ *     private static final Logger logger = Logger.getLogger(&quot;&quot;);
+ *
+ *     private static void logInfo(Description description, String status, long nanos) {
+ *         String testName = description.getMethodName();
+ *         logger.info(String.format(&quot;Test %s %s, spent %d microseconds&quot;,
+ *                                   testName, status, TimeUnit.NANOSECONDS.toMicros(nanos)));
+ *     }
+ *
+ *     &#064;Rule
+ *     public Stopwatch stopwatch = new Stopwatch() {
+ *         &#064;Override
+ *         protected void succeeded(long nanos, Description description) {
+ *             logInfo(description, &quot;succeeded&quot;, nanos);
+ *         }
+ *
+ *         &#064;Override
+ *         protected void failed(long nanos, Throwable e, Description description) {
+ *             logInfo(description, &quot;failed&quot;, nanos);
+ *         }
+ *
+ *         &#064;Override
+ *         protected void skipped(long nanos, AssumptionViolatedException e, Description description) {
+ *             logInfo(description, &quot;skipped&quot;, nanos);
+ *         }
+ *
+ *         &#064;Override
+ *         protected void finished(long nanos, Description description) {
+ *             logInfo(description, &quot;finished&quot;, nanos);
+ *         }
+ *     };
+ *
+ *     &#064;Test
+ *     public void succeeds() {
+ *     }
+ *
+ *     &#064;Test
+ *     public void fails() {
+ *         fail();
+ *     }
+ *
+ *     &#064;Test
+ *     public void skips() {
+ *         assumeTrue(false);
+ *     }
+ * }
+ * </pre>
+ *
+ * An example to assert runtime:
+ * <pre>
+ * &#064;Test
+ * public void performanceTest() throws InterruptedException {
+ *     long delta = 30;
+ *     Thread.sleep(300L);
+ *     assertEquals(300d, stopwatch.runtime(MILLISECONDS), delta);
+ *     Thread.sleep(500L);
+ *     assertEquals(800d, stopwatch.runtime(MILLISECONDS), delta);
+ * }
+ * </pre>
+ *
+ * @author tibor17
+ * @since 4.12
+ */
+public class Stopwatch implements TestRule {
+    private final Clock clock;
+    private volatile long startNanos;
+    private volatile long endNanos;
+
+    public Stopwatch() {
+        this(new Clock());
+    }
+
+    Stopwatch(Clock clock) {
+        this.clock = clock;
+    }
+
+    /**
+     * Gets the runtime for the test.
+     *
+     * @param unit time unit for returned runtime
+     * @return runtime measured during the test
+     */
+    public long runtime(TimeUnit unit) {
+        return unit.convert(getNanos(), TimeUnit.NANOSECONDS);
+    }
+
+    /**
+     * Invoked when a test succeeds
+     */
+    protected void succeeded(long nanos, Description description) {
+    }
+
+    /**
+     * Invoked when a test fails
+     */
+    protected void failed(long nanos, Throwable e, Description description) {
+    }
+
+    /**
+     * Invoked when a test is skipped due to a failed assumption.
+     */
+    protected void skipped(long nanos, AssumptionViolatedException e, Description description) {
+    }
+
+    /**
+     * Invoked when a test method finishes (whether passing or failing)
+     */
+    protected void finished(long nanos, Description description) {
+    }
+
+    private long getNanos() {
+        if (startNanos == 0) {
+            throw new IllegalStateException("Test has not started");
+        }
+        long currentEndNanos = endNanos; // volatile read happens here
+        if (currentEndNanos == 0) {
+          currentEndNanos = clock.nanoTime();
+        }
+
+        return currentEndNanos - startNanos;
+    }
+
+    private void starting() {
+        startNanos = clock.nanoTime();
+        endNanos = 0;
+    }
+
+    private void stopping() {
+        endNanos = clock.nanoTime();
+    }
+
+    public final Statement apply(Statement base, Description description) {
+        return new InternalWatcher().apply(base, description);
+    }
+
+    private class InternalWatcher extends TestWatcher {
+
+        @Override protected void starting(Description description) {
+            Stopwatch.this.starting();
+        }
+
+        @Override protected void finished(Description description) {
+            Stopwatch.this.finished(getNanos(), description);
+        }
+
+        @Override protected void succeeded(Description description) {
+            Stopwatch.this.stopping();
+            Stopwatch.this.succeeded(getNanos(), description);
+        }
+
+        @Override protected void failed(Throwable e, Description description) {
+            Stopwatch.this.stopping();
+            Stopwatch.this.failed(getNanos(), e, description);
+        }
+
+        @Override protected void skipped(AssumptionViolatedException e, Description description) {
+            Stopwatch.this.stopping();
+            Stopwatch.this.skipped(getNanos(), e, description);
+        }
+    }
+
+    static class Clock {
+
+        public long nanoTime() {
+            return System.nanoTime();
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/TemporaryFolder.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/TemporaryFolder.java
new file mode 100644
index 0000000..a726c66
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/TemporaryFolder.java
@@ -0,0 +1,351 @@
+package org.junit.rules;
+
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import org.junit.Rule;
+
+/**
+ * The TemporaryFolder Rule allows creation of files and folders that should
+ * be deleted when the test method finishes (whether it passes or
+ * fails).
+ * By default no exception will be thrown in case the deletion fails.
+ *
+ * <p>Example of usage:
+ * <pre>
+ * public static class HasTempFolder {
+ *  &#064;Rule
+ *  public TemporaryFolder folder= new TemporaryFolder();
+ *
+ *  &#064;Test
+ *  public void testUsingTempFolder() throws IOException {
+ *      File createdFile= folder.newFile(&quot;myfile.txt&quot;);
+ *      File createdFolder= folder.newFolder(&quot;subfolder&quot;);
+ *      // ...
+ *     }
+ * }
+ * </pre>
+ *
+ * <p>TemporaryFolder rule supports assured deletion mode, which
+ * will fail the test in case deletion fails with {@link AssertionError}.
+ *
+ * <p>Creating TemporaryFolder with assured deletion:
+ * <pre>
+ *  &#064;Rule
+ *  public TemporaryFolder folder= TemporaryFolder.builder().assureDeletion().build();
+ * </pre>
+ *
+ * @since 4.7
+ */
+public class TemporaryFolder extends ExternalResource {
+    private final File parentFolder;
+    private final boolean assureDeletion;
+    private File folder;
+
+    private static final int TEMP_DIR_ATTEMPTS = 10000;
+    private static final String TMP_PREFIX = "junit";
+
+    /**
+     * Create a temporary folder which uses system default temporary-file 
+     * directory to create temporary resources.
+     */
+    public TemporaryFolder() {
+        this((File) null);
+    }
+
+    /**
+     * Create a temporary folder which uses the specified directory to create
+     * temporary resources.
+     *
+     * @param parentFolder folder where temporary resources will be created.
+     * If {@code null} then system default temporary-file directory is used.
+     */
+    public TemporaryFolder(File parentFolder) {
+        this.parentFolder = parentFolder;
+        this.assureDeletion = false;
+    }
+
+    /**
+     * Create a {@link TemporaryFolder} initialized with
+     * values from a builder.
+     */
+    protected TemporaryFolder(Builder builder) {
+        this.parentFolder = builder.parentFolder;
+        this.assureDeletion = builder.assureDeletion;
+    }
+
+    /**
+     * Returns a new builder for building an instance of {@link TemporaryFolder}.
+     *
+     * @since 4.13
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /**
+     * Builds an instance of {@link TemporaryFolder}.
+     * 
+     * @since 4.13
+     */
+    public static class Builder {
+        private File parentFolder;
+        private boolean assureDeletion;
+
+        protected Builder() {}
+
+        /**
+         * Specifies which folder to use for creating temporary resources.
+         * If {@code null} then system default temporary-file directory is
+         * used.
+         *
+         * @return this
+         */
+        public Builder parentFolder(File parentFolder) {
+            this.parentFolder = parentFolder;
+            return this;
+        }
+
+        /**
+         * Setting this flag assures that no resources are left undeleted. Failure
+         * to fulfill the assurance results in failure of tests with an
+         * {@link AssertionError}.
+         *
+         * @return this
+         */
+        public Builder assureDeletion() {
+            this.assureDeletion = true;
+            return this;
+        }
+
+        /**
+         * Builds a {@link TemporaryFolder} instance using the values in this builder.
+         */
+        public TemporaryFolder build() {
+            return new TemporaryFolder(this);
+        }
+    }
+
+    @Override
+    protected void before() throws Throwable {
+        create();
+    }
+
+    @Override
+    protected void after() {
+        delete();
+    }
+
+    // testing purposes only
+
+    /**
+     * for testing purposes only. Do not use.
+     */
+    public void create() throws IOException {
+        folder = createTemporaryFolderIn(parentFolder);
+    }
+
+    /**
+     * Returns a new fresh file with the given name under the temporary folder.
+     */
+    public File newFile(String fileName) throws IOException {
+        File file = new File(getRoot(), fileName);
+        if (!file.createNewFile()) {
+            throw new IOException(
+                    "a file with the name \'" + fileName + "\' already exists in the test folder");
+        }
+        return file;
+    }
+
+    /**
+     * Returns a new fresh file with a random name under the temporary folder.
+     */
+    public File newFile() throws IOException {
+        return File.createTempFile(TMP_PREFIX, null, getRoot());
+    }
+
+    /**
+     * Returns a new fresh folder with the given path under the temporary
+     * folder.
+     */
+    public File newFolder(String path) throws IOException {
+        return newFolder(new String[]{path});
+    }
+
+    /**
+     * Returns a new fresh folder with the given paths under the temporary
+     * folder. For example, if you pass in the strings {@code "parent"} and {@code "child"}
+     * then a directory named {@code "parent"} will be created under the temporary folder
+     * and a directory named {@code "child"} will be created under the newly-created
+     * {@code "parent"} directory.
+     */
+    public File newFolder(String... paths) throws IOException {
+        if (paths.length == 0) {
+            throw new IllegalArgumentException("must pass at least one path");
+        }
+
+        /*
+         * Before checking if the paths are absolute paths, check if create() was ever called,
+         * and if it wasn't, throw IllegalStateException.
+         */
+        File root = getRoot();
+        for (String path : paths) {
+            if (new File(path).isAbsolute()) {
+                throw new IOException("folder path \'" + path + "\' is not a relative path");
+            }
+        }
+
+        File relativePath = null;
+        File file = root;
+        boolean lastMkdirsCallSuccessful = true;
+        for (String path : paths) {
+            relativePath = new File(relativePath, path);
+            file = new File(root, relativePath.getPath());
+
+            lastMkdirsCallSuccessful = file.mkdirs();
+            if (!lastMkdirsCallSuccessful && !file.isDirectory()) {
+                if (file.exists()) {
+                    throw new IOException(
+                            "a file with the path \'" + relativePath.getPath() + "\' exists");
+                } else {
+                    throw new IOException(
+                            "could not create a folder with the path \'" + relativePath.getPath() + "\'");
+                }
+            }
+        }
+        if (!lastMkdirsCallSuccessful) {
+            throw new IOException(
+                    "a folder with the path \'" + relativePath.getPath() + "\' already exists");
+        }
+        return file;
+    }
+
+    /**
+     * Returns a new fresh folder with a random name under the temporary folder.
+     */
+    public File newFolder() throws IOException {
+        return createTemporaryFolderIn(getRoot());
+    }
+
+    private static File createTemporaryFolderIn(File parentFolder) throws IOException {
+        try {
+            return createTemporaryFolderWithNioApi(parentFolder);
+        } catch (ClassNotFoundException ignore) {
+            // Fallback for Java 5 and 6
+            return createTemporaryFolderWithFileApi(parentFolder);
+        } catch (InvocationTargetException e) {
+            Throwable cause = e.getCause();
+            if (cause instanceof IOException) {
+                throw (IOException) cause;
+            }
+            if (cause instanceof RuntimeException) {
+                throw (RuntimeException) cause;
+            }
+            IOException exception = new IOException("Failed to create temporary folder in " + parentFolder);
+            exception.initCause(cause);
+            throw exception;
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to create temporary folder in " + parentFolder, e);
+        }
+    }
+
+    private static File createTemporaryFolderWithNioApi(File parentFolder) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+        Class<?> filesClass = Class.forName("java.nio.file.Files");
+        Object fileAttributeArray = Array.newInstance(Class.forName("java.nio.file.attribute.FileAttribute"), 0);
+        Class<?> pathClass = Class.forName("java.nio.file.Path");
+        Object tempDir;
+        if (parentFolder != null) {
+            Method createTempDirectoryMethod = filesClass.getDeclaredMethod("createTempDirectory", pathClass, String.class, fileAttributeArray.getClass());
+            Object parentPath = File.class.getDeclaredMethod("toPath").invoke(parentFolder);
+            tempDir = createTempDirectoryMethod.invoke(null, parentPath, TMP_PREFIX, fileAttributeArray);
+        } else {
+            Method createTempDirectoryMethod = filesClass.getDeclaredMethod("createTempDirectory", String.class, fileAttributeArray.getClass());
+            tempDir = createTempDirectoryMethod.invoke(null, TMP_PREFIX, fileAttributeArray);
+        }
+        return (File) pathClass.getDeclaredMethod("toFile").invoke(tempDir);
+    }
+
+    private static File createTemporaryFolderWithFileApi(File parentFolder) throws IOException {
+        File createdFolder = null;
+        for (int i = 0; i < TEMP_DIR_ATTEMPTS; ++i) {
+            // Use createTempFile to get a suitable folder name.
+            String suffix = ".tmp";
+            File tmpFile = File.createTempFile(TMP_PREFIX, suffix, parentFolder);
+            String tmpName = tmpFile.toString();
+            // Discard .tmp suffix of tmpName.
+            String folderName = tmpName.substring(0, tmpName.length() - suffix.length());
+            createdFolder = new File(folderName);
+            if (createdFolder.mkdir()) {
+                tmpFile.delete();
+                return createdFolder;
+            }
+            tmpFile.delete();
+        }
+        throw new IOException("Unable to create temporary directory in: "
+            + parentFolder.toString() + ". Tried " + TEMP_DIR_ATTEMPTS + " times. "
+            + "Last attempted to create: " + createdFolder.toString());
+    }
+
+    /**
+     * @return the location of this temporary folder.
+     */
+    public File getRoot() {
+        if (folder == null) {
+            throw new IllegalStateException(
+                    "the temporary folder has not yet been created");
+        }
+        return folder;
+    }
+
+    /**
+     * Delete all files and folders under the temporary folder. Usually not
+     * called directly, since it is automatically applied by the {@link Rule}.
+     *
+     * @throws AssertionError if unable to clean up resources
+     * and deletion of resources is assured.
+     */
+    public void delete() {
+        if (!tryDelete()) {
+            if (assureDeletion) {
+                fail("Unable to clean up temporary folder " + folder);
+            }
+        }
+    }
+
+    /**
+     * Tries to delete all files and folders under the temporary folder and
+     * returns whether deletion was successful or not.
+     *
+     * @return {@code true} if all resources are deleted successfully,
+     *         {@code false} otherwise.
+     */
+    private boolean tryDelete() {
+        if (folder == null) {
+            return true;
+        }
+        
+        return recursiveDelete(folder);
+    }
+
+    private boolean recursiveDelete(File file) {
+        // Try deleting file before assuming file is a directory
+        // to prevent following symbolic links.
+        if (file.delete()) {
+            return true;
+        }
+        File[] files = file.listFiles();
+        if (files != null) {
+            for (File each : files) {
+                if (!recursiveDelete(each)) {
+                    return false;
+                }
+            }
+        }
+        return file.delete();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/TestName.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/TestName.java
new file mode 100644
index 0000000..e2ebc2e
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/TestName.java
@@ -0,0 +1,41 @@
+package org.junit.rules;
+
+import org.junit.runner.Description;
+
+/**
+ * The TestName Rule makes the current test name available inside test methods:
+ *
+ * <pre>
+ * public class TestNameTest {
+ *  &#064;Rule
+ *  public TestName name= new TestName();
+ *
+ *  &#064;Test
+ *  public void testA() {
+ *      assertEquals(&quot;testA&quot;, name.getMethodName());
+ *     }
+ *
+ *  &#064;Test
+ *  public void testB() {
+ *      assertEquals(&quot;testB&quot;, name.getMethodName());
+ *     }
+ * }
+ * </pre>
+ *
+ * @since 4.7
+ */
+public class TestName extends TestWatcher {
+    private volatile String name;
+
+    @Override
+    protected void starting(Description d) {
+        name = d.getMethodName();
+    }
+
+    /**
+     * @return the name of the currently-running test method
+     */
+    public String getMethodName() {
+        return name;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/TestRule.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/TestRule.java
new file mode 100644
index 0000000..53e2f70
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/TestRule.java
@@ -0,0 +1,56 @@
+package org.junit.rules;
+
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * A TestRule is an alteration in how a test method, or set of test methods,
+ * is run and reported.  A {@link TestRule} may add additional checks that cause
+ * a test that would otherwise fail to pass, or it may perform necessary setup or
+ * cleanup for tests, or it may observe test execution to report it elsewhere.
+ * {@link TestRule}s can do everything that could be done previously with
+ * methods annotated with {@link org.junit.Before},
+ * {@link org.junit.After}, {@link org.junit.BeforeClass}, or
+ * {@link org.junit.AfterClass}, but they are more powerful, and more easily
+ * shared
+ * between projects and classes.
+ *
+ * The default JUnit test runners for suites and
+ * individual test cases recognize {@link TestRule}s introduced in two different
+ * ways.  {@link org.junit.Rule} annotates method-level
+ * {@link TestRule}s, and {@link org.junit.ClassRule}
+ * annotates class-level {@link TestRule}s.  See Javadoc for those annotations
+ * for more information.
+ *
+ * Multiple {@link TestRule}s can be applied to a test or suite execution. The
+ * {@link Statement} that executes the method or suite is passed to each annotated
+ * {@link org.junit.Rule} in turn, and each may return a substitute or modified
+ * {@link Statement}, which is passed to the next {@link org.junit.Rule}, if any. For
+ * examples of how this can be useful, see these provided TestRules,
+ * or write your own:
+ *
+ * <ul>
+ *   <li>{@link ErrorCollector}: collect multiple errors in one test method</li>
+ *   <li>{@link ExpectedException}: make flexible assertions about thrown exceptions</li>
+ *   <li>{@link ExternalResource}: start and stop a server, for example</li>
+ *   <li>{@link TemporaryFolder}: create fresh files, and delete after test</li>
+ *   <li>{@link TestName}: remember the test name for use during the method</li>
+ *   <li>{@link TestWatcher}: add logic at events during method execution</li>
+ *   <li>{@link Timeout}: cause test to fail after a set time</li>
+ *   <li>{@link Verifier}: fail test if object state ends up incorrect</li>
+ * </ul>
+ *
+ * @since 4.9
+ */
+public interface TestRule {
+    /**
+     * Modifies the method-running {@link Statement} to implement this
+     * test-running rule.
+     *
+     * @param base The {@link Statement} to be modified
+     * @param description A {@link Description} of the test implemented in {@code base}
+     * @return a new statement, which may be the same as {@code base},
+     *         a wrapper around {@code base}, or a completely new Statement.
+     */
+    Statement apply(Statement base, Description description);
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/TestWatcher.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/TestWatcher.java
new file mode 100644
index 0000000..a28514d
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/TestWatcher.java
@@ -0,0 +1,170 @@
+package org.junit.rules;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.AssumptionViolatedException;
+import org.junit.Rule;
+import org.junit.runner.Description;
+import org.junit.runners.model.MultipleFailureException;
+import org.junit.runners.model.Statement;
+
+/**
+ * TestWatcher is a base class for Rules that take note of the testing
+ * action, without modifying it. For example, this class will keep a log of each
+ * passing and failing test:
+ *
+ * <pre>
+ * public static class WatchmanTest {
+ *  private static String watchedLog;
+ *
+ *  &#064;Rule(order = Integer.MIN_VALUE)
+ *  public TestWatcher watchman= new TestWatcher() {
+ *      &#064;Override
+ *      protected void failed(Throwable e, Description description) {
+ *          watchedLog+= description + &quot;\n&quot;;
+ *      }
+ *
+ *      &#064;Override
+ *      protected void succeeded(Description description) {
+ *          watchedLog+= description + &quot; &quot; + &quot;success!\n&quot;;
+ *         }
+ *     };
+ *
+ *  &#064;Test
+ *  public void fails() {
+ *      fail();
+ *  }
+ *
+ *  &#064;Test
+ *  public void succeeds() {
+ *     }
+ * }
+ * </pre>
+ * <p>It is recommended to always set the {@link Rule#order() order} of the
+ * {@code TestWatcher} to {@code Integer.MIN_VALUE} so that it encloses all
+ * other rules. Otherwise it may see failed tests as successful and vice versa
+ * if some rule changes the result of a test (e.g. {@link ErrorCollector} or
+ * {@link ExpectedException}).
+ *
+ * @since 4.9
+ */
+public abstract class TestWatcher implements TestRule {
+    public Statement apply(final Statement base, final Description description) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                List<Throwable> errors = new ArrayList<Throwable>();
+
+                startingQuietly(description, errors);
+                try {
+                    base.evaluate();
+                    succeededQuietly(description, errors);
+                } catch (org.junit.internal.AssumptionViolatedException  e) {
+                    errors.add(e);
+                    skippedQuietly(e, description, errors);
+                } catch (Throwable e) {
+                    errors.add(e);
+                    failedQuietly(e, description, errors);
+                } finally {
+                    finishedQuietly(description, errors);
+                }
+
+                MultipleFailureException.assertEmpty(errors);
+            }
+        };
+    }
+
+    private void succeededQuietly(Description description,
+            List<Throwable> errors) {
+        try {
+            succeeded(description);
+        } catch (Throwable e) {
+            errors.add(e);
+        }
+    }
+
+    private void failedQuietly(Throwable e, Description description,
+            List<Throwable> errors) {
+        try {
+            failed(e, description);
+        } catch (Throwable e1) {
+            errors.add(e1);
+        }
+    }
+
+    private void skippedQuietly(
+            org.junit.internal.AssumptionViolatedException e, Description description,
+            List<Throwable> errors) {
+        try {
+            if (e instanceof AssumptionViolatedException) {
+                skipped((AssumptionViolatedException) e, description);
+            } else {
+                skipped(e, description);
+            }
+        } catch (Throwable e1) {
+            errors.add(e1);
+        }
+    }
+
+    private void startingQuietly(Description description,
+            List<Throwable> errors) {
+        try {
+            starting(description);
+        } catch (Throwable e) {
+            errors.add(e);
+        }
+    }
+
+    private void finishedQuietly(Description description,
+            List<Throwable> errors) {
+        try {
+            finished(description);
+        } catch (Throwable e) {
+            errors.add(e);
+        }
+    }
+
+    /**
+     * Invoked when a test succeeds
+     */
+    protected void succeeded(Description description) {
+    }
+
+    /**
+     * Invoked when a test fails
+     */
+    protected void failed(Throwable e, Description description) {
+    }
+
+    /**
+     * Invoked when a test is skipped due to a failed assumption.
+     */
+    protected void skipped(AssumptionViolatedException e, Description description) {
+        // For backwards compatibility with JUnit 4.11 and earlier, call the legacy version
+        org.junit.internal.AssumptionViolatedException asInternalException = e;
+        skipped(asInternalException, description);
+    }
+
+    /**
+     * Invoked when a test is skipped due to a failed assumption.
+     *
+     * @deprecated use {@link #skipped(AssumptionViolatedException, Description)}
+     */
+    @Deprecated
+    protected void skipped(
+            org.junit.internal.AssumptionViolatedException e, Description description) {
+    }
+
+    /**
+     * Invoked when a test is about to start
+     */
+    protected void starting(Description description) {
+    }
+
+    /**
+     * Invoked when a test method finishes (whether passing or failing)
+     */
+    protected void finished(Description description) {
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/TestWatchman.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/TestWatchman.java
new file mode 100644
index 0000000..c8d6c71
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/TestWatchman.java
@@ -0,0 +1,91 @@
+package org.junit.rules;
+
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+/**
+ * TestWatchman is a base class for Rules that take note of the testing
+ * action, without modifying it. For example, this class will keep a log of each
+ * passing and failing test:
+ *
+ * <pre>
+ * public static class WatchmanTest {
+ *  private static String watchedLog;
+ *
+ *  &#064;Rule
+ *  public MethodRule watchman= new TestWatchman() {
+ *      &#064;Override
+ *      public void failed(Throwable e, FrameworkMethod method) {
+ *          watchedLog+= method.getName() + &quot; &quot; + e.getClass().getSimpleName()
+ *                  + &quot;\n&quot;;
+ *         }
+ *
+ *      &#064;Override
+ *      public void succeeded(FrameworkMethod method) {
+ *          watchedLog+= method.getName() + &quot; &quot; + &quot;success!\n&quot;;
+ *         }
+ *     };
+ *
+ *  &#064;Test
+ *  public void fails() {
+ *      fail();
+ *     }
+ *
+ *  &#064;Test
+ *  public void succeeds() {
+ *     }
+ * }
+ * </pre>
+ *
+ * @since 4.7
+ * @deprecated Use {@link TestWatcher} (which implements {@link TestRule}) instead.
+ */
+@Deprecated
+public class TestWatchman implements MethodRule {
+    public Statement apply(final Statement base, final FrameworkMethod method,
+            Object target) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                starting(method);
+                try {
+                    base.evaluate();
+                    succeeded(method);
+                } catch (AssumptionViolatedException e) {
+                    throw e;
+                } catch (Throwable e) {
+                    failed(e, method);
+                    throw e;
+                } finally {
+                    finished(method);
+                }
+            }
+        };
+    }
+
+    /**
+     * Invoked when a test method succeeds
+     */
+    public void succeeded(FrameworkMethod method) {
+    }
+
+    /**
+     * Invoked when a test method fails
+     */
+    public void failed(Throwable e, FrameworkMethod method) {
+    }
+
+    /**
+     * Invoked when a test method is about to start
+     */
+    public void starting(FrameworkMethod method) {
+    }
+
+
+    /**
+     * Invoked when a test method finishes (whether passing or failing)
+     */
+    public void finished(FrameworkMethod method) {
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/Timeout.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/Timeout.java
new file mode 100644
index 0000000..334a923
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/Timeout.java
@@ -0,0 +1,233 @@
+package org.junit.rules;
+
+import org.junit.internal.runners.statements.FailOnTimeout;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * The Timeout Rule applies the same timeout to all test methods in a class:
+ * <pre>
+ * public static class HasGlobalLongTimeout {
+ *
+ *  &#064;Rule
+ *  public Timeout globalTimeout = Timeout.millis(20);
+ *
+ *  &#064;Test
+ *  public void run1() throws InterruptedException {
+ *      Thread.sleep(100);
+ *  }
+ *
+ *  &#064;Test
+ *  public void infiniteLoop() {
+ *      while (true) {}
+ *  }
+ * }
+ * </pre>
+ * <p>
+ * Each test is run in a new thread. If the specified timeout elapses before
+ * the test completes, its execution is interrupted via {@link Thread#interrupt()}.
+ * This happens in interruptable I/O and locks, and methods in {@link Object}
+ * and {@link Thread} throwing {@link InterruptedException}.
+ * <p>
+ * A specified timeout of 0 will be interpreted as not set, however tests will
+ * still launch from separate threads. This can be useful for disabling timeouts
+ * in environments where they are dynamically set based on some property.
+ *
+ * @since 4.7
+ */
+public class Timeout implements TestRule {
+    private final long timeout;
+    private final TimeUnit timeUnit;
+    private final boolean lookForStuckThread;
+
+    /**
+     * Returns a new builder for building an instance.
+     *
+     * @since 4.12
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /**
+     * Create a {@code Timeout} instance with the timeout specified
+     * in milliseconds.
+     * <p>
+     * This constructor is deprecated.
+     * <p>
+     * Instead use {@link #Timeout(long, java.util.concurrent.TimeUnit)},
+     * {@link Timeout#millis(long)}, or {@link Timeout#seconds(long)}.
+     *
+     * @param millis the maximum time in milliseconds to allow the
+     * test to run before it should timeout
+     */
+    @Deprecated
+    public Timeout(int millis) {
+        this(millis, TimeUnit.MILLISECONDS);
+    }
+
+    /**
+     * Create a {@code Timeout} instance with the timeout specified
+     * at the timeUnit of granularity of the provided {@code TimeUnit}.
+     *
+     * @param timeout the maximum time to allow the test to run
+     * before it should timeout
+     * @param timeUnit the time unit for the {@code timeout}
+     * @since 4.12
+     */
+    public Timeout(long timeout, TimeUnit timeUnit) {
+        this.timeout = timeout;
+        this.timeUnit = timeUnit;
+        lookForStuckThread = false;
+    }
+
+    /**
+     * Create a {@code Timeout} instance initialized with values from
+     * a builder.
+     *
+     * @since 4.12
+     */
+    protected Timeout(Builder builder) {
+        timeout = builder.getTimeout();
+        timeUnit = builder.getTimeUnit();
+        lookForStuckThread = builder.getLookingForStuckThread();
+    }
+
+    /**
+     * Creates a {@link Timeout} that will timeout a test after the
+     * given duration, in milliseconds.
+     *
+     * @since 4.12
+     */
+    public static Timeout millis(long millis) {
+        return new Timeout(millis, TimeUnit.MILLISECONDS);
+    }
+
+    /**
+     * Creates a {@link Timeout} that will timeout a test after the
+     * given duration, in seconds.
+     *
+     * @since 4.12
+     */
+    public static Timeout seconds(long seconds) {
+        return new Timeout(seconds, TimeUnit.SECONDS);
+    }
+
+    /**
+     * Gets the timeout configured for this rule, in the given units.
+     *
+     * @since 4.12
+     */
+    protected final long getTimeout(TimeUnit unit) {
+        return unit.convert(timeout, timeUnit);
+    }
+
+    /**
+     * Gets whether this {@code Timeout} will look for a stuck thread
+     * when the test times out.
+     *
+     * @since 4.12
+     */
+    protected final boolean getLookingForStuckThread() {
+        return lookForStuckThread;
+    }
+
+    /**
+     * Creates a {@link Statement} that will run the given
+     * {@code statement}, and timeout the operation based
+     * on the values configured in this rule. Subclasses
+     * can override this method for different behavior.
+     *
+     * @since 4.12
+     */
+    protected Statement createFailOnTimeoutStatement(
+            Statement statement) throws Exception {
+        return FailOnTimeout.builder()
+            .withTimeout(timeout, timeUnit)
+            .withLookingForStuckThread(lookForStuckThread)
+            .build(statement);
+    }
+
+    public Statement apply(Statement base, Description description) {
+        try {
+            return createFailOnTimeoutStatement(base);
+        } catch (final Exception e) {
+            return new Statement() {
+                @Override public void evaluate() throws Throwable {
+                    throw new RuntimeException("Invalid parameters for Timeout", e);
+                }
+            };
+        }
+    }
+
+    /**
+     * Builder for {@link Timeout}.
+     *
+     * @since 4.12
+     */
+    public static class Builder {
+        private boolean lookForStuckThread = false;
+        private long timeout = 0;
+        private TimeUnit timeUnit = TimeUnit.SECONDS;
+
+        protected Builder() {
+        }
+
+        /**
+         * Specifies the time to wait before timing out the test.
+         *
+         * <p>If this is not called, or is called with a
+         * {@code timeout} of {@code 0}, the returned {@code Timeout}
+         * rule instance will cause the tests to wait forever to
+         * complete, however the tests will still launch from a
+         * separate thread. This can be useful for disabling timeouts
+         * in environments where they are dynamically set based on
+         * some property.
+         *
+         * @param timeout the maximum time to wait
+         * @param unit the time unit of the {@code timeout} argument
+         * @return {@code this} for method chaining.
+         */
+        public Builder withTimeout(long timeout, TimeUnit unit) {
+            this.timeout = timeout;
+            this.timeUnit = unit;
+            return this;
+        }
+
+        protected long getTimeout() {
+            return timeout;
+        }
+
+        protected TimeUnit getTimeUnit()  {
+            return timeUnit;
+        }
+
+        /**
+         * Specifies whether to look for a stuck thread.  If a timeout occurs and this
+         * feature is enabled, the rule will look for a thread that appears to be stuck
+         * and dump its backtrace.  This feature is experimental.  Behavior may change
+         * after the 4.12 release in response to feedback.
+         *
+         * @param enable {@code true} to enable the feature
+         * @return {@code this} for method chaining.
+         */
+        public Builder withLookingForStuckThread(boolean enable) {
+            this.lookForStuckThread = enable;
+            return this;
+        }
+
+        protected boolean getLookingForStuckThread() {
+            return lookForStuckThread;
+        }
+
+
+        /**
+         * Builds a {@link Timeout} instance using the values in this builder.,
+         */
+        public Timeout build() {
+            return new Timeout(this);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/rules/Verifier.java b/google3/third_party/java_src/junit/main/java/org/junit/rules/Verifier.java
new file mode 100644
index 0000000..7a03b0c
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/rules/Verifier.java
@@ -0,0 +1,47 @@
+package org.junit.rules;
+
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * Verifier is a base class for Rules like ErrorCollector, which can turn
+ * otherwise passing test methods into failing tests if a verification check is
+ * failed
+ *
+ * <pre>
+ *     public static class ErrorLogVerifier {
+ *        private ErrorLog errorLog = new ErrorLog();
+ *
+ *        &#064;Rule
+ *        public Verifier verifier = new Verifier() {
+ *           &#064;Override public void verify() {
+ *              assertTrue(errorLog.isEmpty());
+ *           }
+ *        }
+ *
+ *        &#064;Test public void testThatMightWriteErrorLog() {
+ *           // ...
+ *        }
+ *     }
+ * </pre>
+ *
+ * @since 4.7
+ */
+public abstract class Verifier implements TestRule {
+    public Statement apply(final Statement base, Description description) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                base.evaluate();
+                verify();
+            }
+        };
+    }
+
+    /**
+     * Override this to add verification logic. Overrides should throw an
+     * exception to indicate that verification failed.
+     */
+    protected void verify() throws Throwable {
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/Computer.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/Computer.java
new file mode 100644
index 0000000..18d0d31
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/Computer.java
@@ -0,0 +1,52 @@
+package org.junit.runner;
+
+import org.junit.runners.Suite;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.RunnerBuilder;
+
+/**
+ * Represents a strategy for computing runners and suites.
+ * WARNING: this class is very likely to undergo serious changes in version 4.8 and
+ * beyond.
+ *
+ * @since 4.6
+ */
+public class Computer {
+    /**
+     * Returns a new default computer, which runs tests in serial order
+     */
+    public static Computer serial() {
+        return new Computer();
+    }
+
+    /**
+     * Create a suite for {@code classes}, building Runners with {@code builder}.
+     * Throws an InitializationError if Runner construction fails
+     */
+    public Runner getSuite(final RunnerBuilder builder,
+            Class<?>[] classes) throws InitializationError {
+        return new Suite(new RunnerBuilder() {
+            @Override
+            public Runner runnerForClass(Class<?> testClass) throws Throwable {
+                return getRunner(builder, testClass);
+            }
+        }, classes) {
+            @Override
+            protected String getName() {
+                /*
+                 * #1320 The generated suite is not based on a real class so
+                 * only a 'null' description can be generated from it. This name
+                 * will be overridden here.
+                 */
+                return "classes";
+            }
+        };
+    }
+
+    /**
+     * Create a single-class runner for {@code testClass}, using {@code builder}
+     */
+    protected Runner getRunner(RunnerBuilder builder, Class<?> testClass) throws Throwable {
+        return builder.runnerForClass(testClass);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/Describable.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/Describable.java
new file mode 100644
index 0000000..293fdb3
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/Describable.java
@@ -0,0 +1,14 @@
+package org.junit.runner;
+
+
+/**
+ * Represents an object that can describe itself
+ *
+ * @since 4.5
+ */
+public interface Describable {
+    /**
+     * @return a {@link Description} showing the tests to be run by the receiver
+     */
+    Description getDescription();
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/Description.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/Description.java
new file mode 100644
index 0000000..0846a1e
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/Description.java
@@ -0,0 +1,327 @@
+package org.junit.runner;
+
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * A <code>Description</code> describes a test which is to be run or has been run. <code>Descriptions</code>
+ * can be atomic (a single test) or compound (containing children tests). <code>Descriptions</code> are used
+ * to provide feedback about the tests that are about to run (for example, the tree view
+ * visible in many IDEs) or tests that have been run (for example, the failures view).
+ * <p>
+ * <code>Descriptions</code> are implemented as a single class rather than a Composite because
+ * they are entirely informational. They contain no logic aside from counting their tests.
+ * <p>
+ * In the past, we used the raw {@link junit.framework.TestCase}s and {@link junit.framework.TestSuite}s
+ * to display the tree of tests. This was no longer viable in JUnit 4 because atomic tests no longer have
+ * a superclass below {@link Object}. We needed a way to pass a class and name together. Description
+ * emerged from this.
+ *
+ * @see org.junit.runner.Request
+ * @see org.junit.runner.Runner
+ * @since 4.0
+ */
+public class Description implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    private static final Pattern METHOD_AND_CLASS_NAME_PATTERN = Pattern
+            .compile("([\\s\\S]*)\\((.*)\\)");
+
+    /**
+     * Create a <code>Description</code> named <code>name</code>.
+     * Generally, you will add children to this <code>Description</code>.
+     *
+     * @param name the name of the <code>Description</code>
+     * @param annotations meta-data about the test, for downstream interpreters
+     * @return a <code>Description</code> named <code>name</code>
+     */
+    public static Description createSuiteDescription(String name, Annotation... annotations) {
+        return new Description(null, name, annotations);
+    }
+
+    /**
+     * Create a <code>Description</code> named <code>name</code>.
+     * Generally, you will add children to this <code>Description</code>.
+     *
+     * @param name the name of the <code>Description</code>
+     * @param uniqueId an arbitrary object used to define uniqueness (in {@link #equals(Object)}
+     * @param annotations meta-data about the test, for downstream interpreters
+     * @return a <code>Description</code> named <code>name</code>
+     */
+    public static Description createSuiteDescription(String name, Serializable uniqueId, Annotation... annotations) {
+        return new Description(null, name, uniqueId, annotations);
+    }
+
+    /**
+     * Create a <code>Description</code> of a single test named <code>name</code> in the 'class' named
+     * <code>className</code>. Generally, this will be a leaf <code>Description</code>. This method is a better choice
+     * than {@link #createTestDescription(Class, String, Annotation...)} for test runners whose test cases are not
+     * defined in an actual Java <code>Class</code>.
+     *
+     * @param className the class name of the test
+     * @param name the name of the test (a method name for test annotated with {@link org.junit.Test})
+     * @param annotations meta-data about the test, for downstream interpreters
+     * @return a <code>Description</code> named <code>name</code>
+     */
+    public static Description createTestDescription(String className, String name, Annotation... annotations) {
+        return new Description(null, formatDisplayName(name, className), annotations);
+    }
+
+    /**
+     * Create a <code>Description</code> of a single test named <code>name</code> in the class <code>clazz</code>.
+     * Generally, this will be a leaf <code>Description</code>.
+     *
+     * @param clazz the class of the test
+     * @param name the name of the test (a method name for test annotated with {@link org.junit.Test})
+     * @param annotations meta-data about the test, for downstream interpreters
+     * @return a <code>Description</code> named <code>name</code>
+     */
+    public static Description createTestDescription(Class<?> clazz, String name, Annotation... annotations) {
+        return new Description(clazz, formatDisplayName(name, clazz.getName()), annotations);
+    }
+
+    /**
+     * Create a <code>Description</code> of a single test named <code>name</code> in the class <code>clazz</code>.
+     * Generally, this will be a leaf <code>Description</code>.
+     * (This remains for binary compatibility with clients of JUnit 4.3)
+     *
+     * @param clazz the class of the test
+     * @param name the name of the test (a method name for test annotated with {@link org.junit.Test})
+     * @return a <code>Description</code> named <code>name</code>
+     */
+    public static Description createTestDescription(Class<?> clazz, String name) {
+        return new Description(clazz, formatDisplayName(name, clazz.getName()));
+    }
+
+    /**
+     * Create a <code>Description</code> of a single test named <code>name</code> in the class <code>clazz</code>.
+     * Generally, this will be a leaf <code>Description</code>.
+     *
+     * @param name the name of the test (a method name for test annotated with {@link org.junit.Test})
+     * @return a <code>Description</code> named <code>name</code>
+     */
+    public static Description createTestDescription(String className, String name, Serializable uniqueId) {
+        return new Description(null, formatDisplayName(name, className), uniqueId);
+    }
+
+    private static String formatDisplayName(String name, String className) {
+        return String.format("%s(%s)", name, className);
+    }
+
+    /**
+     * Create a <code>Description</code> named after <code>testClass</code>
+     *
+     * @param testClass A {@link Class} containing tests
+     * @return a <code>Description</code> of <code>testClass</code>
+     */
+    public static Description createSuiteDescription(Class<?> testClass) {
+        return new Description(testClass, testClass.getName(), testClass.getAnnotations());
+    }
+
+    /**
+     * Create a <code>Description</code> named after <code>testClass</code>
+     *
+     * @param testClass A not null {@link Class} containing tests
+     * @param annotations meta-data about the test, for downstream interpreters
+     * @return a <code>Description</code> of <code>testClass</code>
+     */
+    public static Description createSuiteDescription(Class<?> testClass, Annotation... annotations) {
+        return new Description(testClass, testClass.getName(), annotations);
+    }
+
+    /**
+     * Describes a Runner which runs no tests
+     */
+    public static final Description EMPTY = new Description(null, "No Tests");
+
+    /**
+     * Describes a step in the test-running mechanism that goes so wrong no
+     * other description can be used (for example, an exception thrown from a Runner's
+     * constructor
+     */
+    public static final Description TEST_MECHANISM = new Description(null, "Test mechanism");
+
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit4/issues/976
+     */
+    private final Collection<Description> fChildren = new ConcurrentLinkedQueue<Description>();
+    private final String fDisplayName;
+    private final Serializable fUniqueId;
+    private final Annotation[] fAnnotations;
+    private volatile /* write-once */ Class<?> fTestClass;
+
+    private Description(Class<?> clazz, String displayName, Annotation... annotations) {
+        this(clazz, displayName, displayName, annotations);
+    }
+
+    private Description(Class<?> testClass, String displayName, Serializable uniqueId, Annotation... annotations) {
+        if ((displayName == null) || (displayName.length() == 0)) {
+            throw new IllegalArgumentException(
+                    "The display name must not be empty.");
+        }
+        if ((uniqueId == null)) {
+            throw new IllegalArgumentException(
+                    "The unique id must not be null.");
+        }
+        this.fTestClass = testClass;
+        this.fDisplayName = displayName;
+        this.fUniqueId = uniqueId;
+        this.fAnnotations = annotations;
+    }
+
+    /**
+     * @return a user-understandable label
+     */
+    public String getDisplayName() {
+        return fDisplayName;
+    }
+
+    /**
+     * Add <code>Description</code> as a child of the receiver.
+     *
+     * @param description the soon-to-be child.
+     */
+    public void addChild(Description description) {
+        fChildren.add(description);
+    }
+
+    /**
+     * Gets the copy of the children of this {@code Description}.
+     * Returns an empty list if there are no children.
+     */
+    public ArrayList<Description> getChildren() {
+        return new ArrayList<Description>(fChildren);
+    }
+
+    /**
+     * @return <code>true</code> if the receiver is a suite
+     */
+    public boolean isSuite() {
+        return !isTest();
+    }
+
+    /**
+     * @return <code>true</code> if the receiver is an atomic test
+     */
+    public boolean isTest() {
+        return fChildren.isEmpty();
+    }
+
+    /**
+     * @return the total number of atomic tests in the receiver
+     */
+    public int testCount() {
+        if (isTest()) {
+            return 1;
+        }
+        int result = 0;
+        for (Description child : fChildren) {
+            result += child.testCount();
+        }
+        return result;
+    }
+
+    @Override
+    public int hashCode() {
+        return fUniqueId.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Description)) {
+            return false;
+        }
+        Description d = (Description) obj;
+        return fUniqueId.equals(d.fUniqueId);
+    }
+
+    @Override
+    public String toString() {
+        return getDisplayName();
+    }
+
+    /**
+     * @return true if this is a description of a Runner that runs no tests
+     */
+    public boolean isEmpty() {
+        return equals(EMPTY);
+    }
+
+    /**
+     * @return a copy of this description, with no children (on the assumption that some of the
+     *         children will be added back)
+     */
+    public Description childlessCopy() {
+        return new Description(fTestClass, fDisplayName, fAnnotations);
+    }
+
+    /**
+     * @return the annotation of type annotationType that is attached to this description node,
+     *         or null if none exists
+     */
+    public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
+        for (Annotation each : fAnnotations) {
+            if (each.annotationType().equals(annotationType)) {
+                return annotationType.cast(each);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * @return all of the annotations attached to this description node
+     */
+    public Collection<Annotation> getAnnotations() {
+        return Arrays.asList(fAnnotations);
+    }
+
+    /**
+     * @return If this describes a method invocation,
+     *         the class of the test instance.
+     */
+    public Class<?> getTestClass() {
+        if (fTestClass != null) {
+            return fTestClass;
+        }
+        String name = getClassName();
+        if (name == null) {
+            return null;
+        }
+        try {
+            fTestClass = Class.forName(name, false, getClass().getClassLoader());
+            return fTestClass;
+        } catch (ClassNotFoundException e) {
+            return null;
+        }
+    }
+
+    /**
+     * @return If this describes a method invocation,
+     *         the name of the class of the test instance
+     */
+    public String getClassName() {
+        return fTestClass != null ? fTestClass.getName() : methodAndClassNamePatternGroupOrDefault(2, toString());
+    }
+
+    /**
+     * @return If this describes a method invocation,
+     *         the name of the method (or null if not)
+     */
+    public String getMethodName() {
+        return methodAndClassNamePatternGroupOrDefault(1, null);
+    }
+
+    private String methodAndClassNamePatternGroupOrDefault(int group,
+            String defaultString) {
+        Matcher matcher = METHOD_AND_CLASS_NAME_PATTERN.matcher(toString());
+        return matcher.matches() ? matcher.group(group) : defaultString;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/FilterFactories.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/FilterFactories.java
new file mode 100644
index 0000000..1160359
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/FilterFactories.java
@@ -0,0 +1,82 @@
+package org.junit.runner;
+
+import org.junit.internal.Classes;
+import org.junit.runner.FilterFactory.FilterNotCreatedException;
+import org.junit.runner.manipulation.Filter;
+
+/**
+ * Utility class whose methods create a {@link FilterFactory}.
+ */
+class FilterFactories {
+    /**
+     * Creates a {@link Filter}.
+     *
+     * A filter specification is of the form "package.of.FilterFactory=args-to-filter-factory" or
+     * "package.of.FilterFactory".
+     *
+     * @param request the request that will be filtered
+     * @param filterSpec the filter specification
+     * @throws org.junit.runner.FilterFactory.FilterNotCreatedException
+     */
+    public static Filter createFilterFromFilterSpec(Request request, String filterSpec)
+            throws FilterFactory.FilterNotCreatedException {
+        Description topLevelDescription = request.getRunner().getDescription();
+        String[] tuple;
+
+        if (filterSpec.contains("=")) {
+            tuple = filterSpec.split("=", 2);
+        } else {
+            tuple = new String[]{ filterSpec, "" };
+        }
+
+        return createFilter(tuple[0], new FilterFactoryParams(topLevelDescription, tuple[1]));
+    }
+
+    /**
+     * Creates a {@link Filter}.
+     *
+     * @param filterFactoryFqcn The fully qualified class name of the {@link FilterFactory}
+     * @param params The arguments to the {@link FilterFactory}
+     */
+    public static Filter createFilter(String filterFactoryFqcn, FilterFactoryParams params)
+            throws FilterFactory.FilterNotCreatedException {
+        FilterFactory filterFactory = createFilterFactory(filterFactoryFqcn);
+
+        return filterFactory.createFilter(params);
+    }
+
+    /**
+     * Creates a {@link Filter}.
+     *
+     * @param filterFactoryClass The class of the {@link FilterFactory}
+     * @param params             The arguments to the {@link FilterFactory}
+     *
+     */
+    public static Filter createFilter(Class<? extends FilterFactory> filterFactoryClass, FilterFactoryParams params)
+            throws FilterFactory.FilterNotCreatedException {
+        FilterFactory filterFactory = createFilterFactory(filterFactoryClass);
+
+        return filterFactory.createFilter(params);
+    }
+
+    static FilterFactory createFilterFactory(String filterFactoryFqcn) throws FilterNotCreatedException {
+        Class<? extends FilterFactory> filterFactoryClass;
+
+        try {
+            filterFactoryClass = Classes.getClass(filterFactoryFqcn).asSubclass(FilterFactory.class);
+        } catch (Exception e) {
+            throw new FilterNotCreatedException(e);
+        }
+
+        return createFilterFactory(filterFactoryClass);
+    }
+
+    static FilterFactory createFilterFactory(Class<? extends FilterFactory> filterFactoryClass)
+            throws FilterNotCreatedException {
+        try {
+            return filterFactoryClass.getConstructor().newInstance();
+        } catch (Exception e) {
+            throw new FilterNotCreatedException(e);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/FilterFactory.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/FilterFactory.java
new file mode 100644
index 0000000..a966055
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/FilterFactory.java
@@ -0,0 +1,25 @@
+package org.junit.runner;
+
+import org.junit.runner.manipulation.Filter;
+
+/**
+ * Extend this class to create a factory that creates {@link Filter}.
+ */
+public interface FilterFactory {
+    /**
+     * Creates a {@link Filter} given a {@link FilterFactoryParams} argument.
+     *
+     * @param params Parameters needed to create the {@link Filter}
+     */
+    Filter createFilter(FilterFactoryParams params) throws FilterNotCreatedException;
+
+    /**
+     * Exception thrown if the {@link Filter} cannot be created.
+     */
+    @SuppressWarnings("serial")
+    class FilterNotCreatedException extends Exception {
+        public FilterNotCreatedException(Exception exception) {
+            super(exception.getMessage(), exception);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/FilterFactoryParams.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/FilterFactoryParams.java
new file mode 100644
index 0000000..4ef7c23
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/FilterFactoryParams.java
@@ -0,0 +1,23 @@
+package org.junit.runner;
+
+public final class FilterFactoryParams {
+    private final Description topLevelDescription;
+    private final String args;
+
+    public FilterFactoryParams(Description topLevelDescription, String args) {
+        if (args == null || topLevelDescription == null) {
+            throw new NullPointerException();
+        }
+
+        this.topLevelDescription = topLevelDescription;
+        this.args = args;
+    }
+
+    public String getArgs() {
+        return args;
+    }
+
+    public Description getTopLevelDescription() {
+        return topLevelDescription;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/JUnitCommandLineParseResult.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/JUnitCommandLineParseResult.java
new file mode 100644
index 0000000..990c7c6
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/JUnitCommandLineParseResult.java
@@ -0,0 +1,147 @@
+package org.junit.runner;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.internal.Classes;
+import org.junit.runner.FilterFactory.FilterNotCreatedException;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runners.model.InitializationError;
+
+class JUnitCommandLineParseResult {
+    private final List<String> filterSpecs = new ArrayList<String>();
+    private final List<Class<?>> classes = new ArrayList<Class<?>>();
+    private final List<Throwable> parserErrors = new ArrayList<Throwable>();
+
+    /**
+     * Do not use. Testing purposes only.
+     */
+    JUnitCommandLineParseResult() {}
+
+    /**
+     * Returns filter specs parsed from command line.
+     */
+    public List<String> getFilterSpecs() {
+        return Collections.unmodifiableList(filterSpecs);
+    }
+
+    /**
+     * Returns test classes parsed from command line.
+     */
+    public List<Class<?>> getClasses() {
+        return Collections.unmodifiableList(classes);
+    }
+
+    /**
+     * Parses the arguments.
+     *
+     * @param args Arguments
+     */
+    public static JUnitCommandLineParseResult parse(String[] args) {
+        JUnitCommandLineParseResult result = new JUnitCommandLineParseResult();
+
+        result.parseArgs(args);
+
+        return result;
+    }
+
+    private void parseArgs(String[] args) {
+        parseParameters(parseOptions(args));
+    }
+
+    String[] parseOptions(String... args) {
+        for (int i = 0; i != args.length; ++i) {
+            String arg = args[i];
+
+            if (arg.equals("--")) {
+                return copyArray(args, i + 1, args.length);
+            } else if (arg.startsWith("--")) {
+                if (arg.startsWith("--filter=") || arg.equals("--filter")) {
+                    String filterSpec;
+                    if (arg.equals("--filter")) {
+                        ++i;
+
+                        if (i < args.length) {
+                            filterSpec = args[i];
+                        } else {
+                            parserErrors.add(new CommandLineParserError(arg + " value not specified"));
+                            break;
+                        }
+                    } else {
+                        filterSpec = arg.substring(arg.indexOf('=') + 1);
+                    }
+
+                    filterSpecs.add(filterSpec);
+                } else {
+                    parserErrors.add(new CommandLineParserError("JUnit knows nothing about the " + arg + " option"));
+                }
+            } else {
+                return copyArray(args, i, args.length);
+            }
+        }
+
+        return new String[]{};
+    }
+
+    private String[] copyArray(String[] args, int from, int to) {
+        String[] result = new String[to - from];
+        for (int j = from; j != to; ++j) {
+            result[j - from] = args[j];
+        }
+        return result;
+    }
+
+    void parseParameters(String[] args) {
+        for (String arg : args) {
+            try {
+                classes.add(Classes.getClass(arg));
+            } catch (ClassNotFoundException e) {
+                parserErrors.add(new IllegalArgumentException("Could not find class [" + arg + "]", e));
+            }
+        }
+    }
+
+    private Request errorReport(Throwable cause) {
+        return Request.errorReport(JUnitCommandLineParseResult.class, cause);
+    }
+
+    /**
+     * Creates a {@link Request}.
+     *
+     * @param computer {@link Computer} to be used.
+     */
+    public Request createRequest(Computer computer) {
+        if (parserErrors.isEmpty()) {
+            Request request = Request.classes(
+                    computer, classes.toArray(new Class<?>[classes.size()]));
+            return applyFilterSpecs(request);
+        } else {
+            return errorReport(new InitializationError(parserErrors));
+        }
+    }
+
+    private Request applyFilterSpecs(Request request) {
+        try {
+            for (String filterSpec : filterSpecs) {
+                Filter filter = FilterFactories.createFilterFromFilterSpec(
+                        request, filterSpec);
+                request = request.filterWith(filter);
+            }
+            return request;
+        } catch (FilterNotCreatedException e) {
+            return errorReport(e);
+        }
+    }
+
+    /**
+     * Exception used if there's a problem parsing the command line.
+     */
+    public static class CommandLineParserError extends Exception {
+        private static final long serialVersionUID= 1L;
+
+        public CommandLineParserError(String message) {
+            super(message);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/JUnitCore.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/JUnitCore.java
new file mode 100644
index 0000000..c1479e0
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/JUnitCore.java
@@ -0,0 +1,167 @@
+package org.junit.runner;
+
+import junit.runner.Version;
+import org.junit.internal.JUnitSystem;
+import org.junit.internal.RealSystem;
+import org.junit.internal.TextListener;
+import org.junit.internal.runners.JUnit38ClassRunner;
+import org.junit.runner.notification.RunListener;
+import org.junit.runner.notification.RunNotifier;
+
+/**
+ * <code>JUnitCore</code> is a facade for running tests. It supports running JUnit 4 tests,
+ * JUnit 3.8.x tests, and mixtures. To run tests from the command line, run
+ * <code>java org.junit.runner.JUnitCore TestClass1 TestClass2 ...</code>.
+ * For one-shot test runs, use the static method {@link #runClasses(Class[])}.
+ * If you want to add special listeners,
+ * create an instance of {@link org.junit.runner.JUnitCore} first and use it to run the tests.
+ *
+ * @see org.junit.runner.Result
+ * @see org.junit.runner.notification.RunListener
+ * @see org.junit.runner.Request
+ * @since 4.0
+ */
+public class JUnitCore {
+    private final RunNotifier notifier = new RunNotifier();
+
+    /**
+     * Run the tests contained in the classes named in the <code>args</code>.
+     * If all tests run successfully, exit with a status of 0. Otherwise exit with a status of 1.
+     * Write feedback while tests are running and write
+     * stack traces for all failed tests after the tests all complete.
+     *
+     * @param args names of classes in which to find tests to run
+     */
+    public static void main(String... args) {
+        Result result = new JUnitCore().runMain(new RealSystem(), args);
+        System.exit(result.wasSuccessful() ? 0 : 1);
+    }
+
+    /**
+     * Run the tests contained in <code>classes</code>. Write feedback while the tests
+     * are running and write stack traces for all failed tests after all tests complete. This is
+     * similar to {@link #main(String[])}, but intended to be used programmatically.
+     *
+     * @param classes Classes in which to find tests
+     * @return a {@link Result} describing the details of the test run and the failed tests.
+     */
+    public static Result runClasses(Class<?>... classes) {
+        return runClasses(defaultComputer(), classes);
+    }
+
+    /**
+     * Run the tests contained in <code>classes</code>. Write feedback while the tests
+     * are running and write stack traces for all failed tests after all tests complete. This is
+     * similar to {@link #main(String[])}, but intended to be used programmatically.
+     *
+     * @param computer Helps construct Runners from classes
+     * @param classes  Classes in which to find tests
+     * @return a {@link Result} describing the details of the test run and the failed tests.
+     */
+    public static Result runClasses(Computer computer, Class<?>... classes) {
+        return new JUnitCore().run(computer, classes);
+    }
+
+    /**
+     * @param system
+     * @param args from main()
+     */
+    Result runMain(JUnitSystem system, String... args) {
+        system.out().println("JUnit version " + Version.id());
+
+        JUnitCommandLineParseResult jUnitCommandLineParseResult = JUnitCommandLineParseResult.parse(args);
+
+        RunListener listener = new TextListener(system);
+        addListener(listener);
+
+        return run(jUnitCommandLineParseResult.createRequest(defaultComputer()));
+    }
+
+    /**
+     * @return the version number of this release
+     */
+    public String getVersion() {
+        return Version.id();
+    }
+
+    /**
+     * Run all the tests in <code>classes</code>.
+     *
+     * @param classes the classes containing tests
+     * @return a {@link Result} describing the details of the test run and the failed tests.
+     */
+    public Result run(Class<?>... classes) {
+        return run(defaultComputer(), classes);
+    }
+
+    /**
+     * Run all the tests in <code>classes</code>.
+     *
+     * @param computer Helps construct Runners from classes
+     * @param classes the classes containing tests
+     * @return a {@link Result} describing the details of the test run and the failed tests.
+     */
+    public Result run(Computer computer, Class<?>... classes) {
+        return run(Request.classes(computer, classes));
+    }
+
+    /**
+     * Run all the tests contained in <code>request</code>.
+     *
+     * @param request the request describing tests
+     * @return a {@link Result} describing the details of the test run and the failed tests.
+     */
+    public Result run(Request request) {
+        return run(request.getRunner());
+    }
+
+    /**
+     * Run all the tests contained in JUnit 3.8.x <code>test</code>. Here for backward compatibility.
+     *
+     * @param test the old-style test
+     * @return a {@link Result} describing the details of the test run and the failed tests.
+     */
+    public Result run(junit.framework.Test test) {
+        return run(new JUnit38ClassRunner(test));
+    }
+
+    /**
+     * Do not use. Testing purposes only.
+     */
+    public Result run(Runner runner) {
+        Result result = new Result();
+        RunListener listener = result.createListener();
+        notifier.addFirstListener(listener);
+        try {
+            notifier.fireTestRunStarted(runner.getDescription());
+            runner.run(notifier);
+            notifier.fireTestRunFinished(result);
+        } finally {
+            removeListener(listener);
+        }
+        return result;
+    }
+
+    /**
+     * Add a listener to be notified as the tests run.
+     *
+     * @param listener the listener to add
+     * @see org.junit.runner.notification.RunListener
+     */
+    public void addListener(RunListener listener) {
+        notifier.addListener(listener);
+    }
+
+    /**
+     * Remove a listener.
+     *
+     * @param listener the listener to remove
+     */
+    public void removeListener(RunListener listener) {
+        notifier.removeListener(listener);
+    }
+
+    static Computer defaultComputer() {
+        return new Computer();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/OrderWith.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/OrderWith.java
new file mode 100644
index 0000000..e8470c9
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/OrderWith.java
@@ -0,0 +1,28 @@
+package org.junit.runner;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.junit.runner.manipulation.Ordering;
+import org.junit.validator.ValidateWith;
+
+/**
+ * When a test class is annotated with <code>&#064;OrderWith</code> or extends a class annotated
+ * with <code>&#064;OrderWith</code>, JUnit will order the tests in the test class (and child
+ * test classes, if any) using the ordering defined by the {@link Ordering} class.
+ *
+ * @since 4.13
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Inherited
+@ValidateWith(OrderWithValidator.class)
+public @interface OrderWith {
+    /**
+     * Gets a class that extends {@link Ordering}. The class must have a public no-arg constructor.
+     */
+    Class<? extends Ordering.Factory> value();
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/OrderWithValidator.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/OrderWithValidator.java
new file mode 100644
index 0000000..f8eab25
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/OrderWithValidator.java
@@ -0,0 +1,38 @@
+package org.junit.runner;
+
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
+
+import java.util.List;
+
+import org.junit.FixMethodOrder;
+import org.junit.runners.model.TestClass;
+import org.junit.validator.AnnotationValidator;
+
+/**
+ * Validates that there are no errors in the use of the {@code OrderWith}
+ * annotation. If there is, a {@code Throwable} object will be added to the list
+ * of errors.
+ *
+ * @since 4.13
+ */
+public final class OrderWithValidator extends AnnotationValidator {
+
+    /**
+     * Adds to {@code errors} a throwable for each problem detected. Looks for
+     * {@code FixMethodOrder} annotations.
+     *
+     * @param testClass that is being validated
+     * @return A list of exceptions detected
+     *
+     * @since 4.13
+     */
+    @Override
+    public List<Exception> validateAnnotatedClass(TestClass testClass) {
+        if (testClass.getAnnotation(FixMethodOrder.class) != null) {
+            return singletonList(
+                    new Exception("@FixMethodOrder cannot be combined with @OrderWith"));
+        }
+        return emptyList();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/Request.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/Request.java
new file mode 100644
index 0000000..7b9a990
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/Request.java
@@ -0,0 +1,202 @@
+package org.junit.runner;
+
+import java.util.Comparator;
+
+import org.junit.internal.builders.AllDefaultPossibilitiesBuilder;
+import org.junit.internal.requests.ClassRequest;
+import org.junit.internal.requests.FilterRequest;
+import org.junit.internal.requests.OrderingRequest;
+import org.junit.internal.requests.SortingRequest;
+import org.junit.internal.runners.ErrorReportingRunner;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.Ordering;
+import org.junit.runners.model.InitializationError;
+
+/**
+ * A <code>Request</code> is an abstract description of tests to be run. Older versions of
+ * JUnit did not need such a concept--tests to be run were described either by classes containing
+ * tests or a tree of {@link  org.junit.Test}s. However, we want to support filtering and sorting,
+ * so we need a more abstract specification than the tests themselves and a richer
+ * specification than just the classes.
+ *
+ * <p>The flow when JUnit runs tests is that a <code>Request</code> specifies some tests to be run -&gt;
+ * a {@link org.junit.runner.Runner} is created for each class implied by the <code>Request</code> -&gt;
+ * the {@link org.junit.runner.Runner} returns a detailed {@link org.junit.runner.Description}
+ * which is a tree structure of the tests to be run.
+ *
+ * @since 4.0
+ */
+public abstract class Request {
+    /**
+     * Create a <code>Request</code> that, when processed, will run a single test.
+     * This is done by filtering out all other tests. This method is used to support rerunning
+     * single tests.
+     *
+     * @param clazz the class of the test
+     * @param methodName the name of the test
+     * @return a <code>Request</code> that will cause a single test be run
+     */
+    public static Request method(Class<?> clazz, String methodName) {
+        Description method = Description.createTestDescription(clazz, methodName);
+        return Request.aClass(clazz).filterWith(method);
+    }
+
+    /**
+     * Create a <code>Request</code> that, when processed, will run all the tests
+     * in a class. The odd name is necessary because <code>class</code> is a reserved word.
+     *
+     * @param clazz the class containing the tests
+     * @return a <code>Request</code> that will cause all tests in the class to be run
+     */
+    public static Request aClass(Class<?> clazz) {
+        return new ClassRequest(clazz);
+    }
+
+    /**
+     * Create a <code>Request</code> that, when processed, will run all the tests
+     * in a class. If the class has a suite() method, it will be ignored.
+     *
+     * @param clazz the class containing the tests
+     * @return a <code>Request</code> that will cause all tests in the class to be run
+     */
+    public static Request classWithoutSuiteMethod(Class<?> clazz) {
+        return new ClassRequest(clazz, false);
+    }
+
+    /**
+     * Create a <code>Request</code> that, when processed, will run all the tests
+     * in a set of classes.
+     *
+     * @param computer Helps construct Runners from classes
+     * @param classes the classes containing the tests
+     * @return a <code>Request</code> that will cause all tests in the classes to be run
+     */
+    public static Request classes(Computer computer, Class<?>... classes) {
+        try {
+            AllDefaultPossibilitiesBuilder builder = new AllDefaultPossibilitiesBuilder();
+            Runner suite = computer.getSuite(builder, classes);
+            return runner(suite);
+        } catch (InitializationError e) {
+            return runner(new ErrorReportingRunner(e, classes));
+        }
+    }
+
+    /**
+     * Create a <code>Request</code> that, when processed, will run all the tests
+     * in a set of classes with the default <code>Computer</code>.
+     *
+     * @param classes the classes containing the tests
+     * @return a <code>Request</code> that will cause all tests in the classes to be run
+     */
+    public static Request classes(Class<?>... classes) {
+        return classes(JUnitCore.defaultComputer(), classes);
+    }
+
+
+    /**
+     * Creates a {@link Request} that, when processed, will report an error for the given
+     * test class with the given cause.
+     */
+    public static Request errorReport(Class<?> klass, Throwable cause) {
+        return runner(new ErrorReportingRunner(klass, cause));
+    }
+
+    /**
+     * @param runner the runner to return
+     * @return a <code>Request</code> that will run the given runner when invoked
+     */
+    public static Request runner(final Runner runner) {
+        return new Request() {
+            @Override
+            public Runner getRunner() {
+                return runner;
+            }
+        };
+    }
+
+    /**
+     * Returns a {@link Runner} for this Request
+     *
+     * @return corresponding {@link Runner} for this Request
+     */
+    public abstract Runner getRunner();
+
+    /**
+     * Returns a Request that only contains those tests that should run when
+     * <code>filter</code> is applied
+     *
+     * @param filter The {@link Filter} to apply to this Request
+     * @return the filtered Request
+     */
+    public Request filterWith(Filter filter) {
+        return new FilterRequest(this, filter);
+    }
+
+    /**
+     * Returns a Request that only runs tests whose {@link Description}
+     * matches the given description.
+     *
+     * <p>Returns an empty {@code Request} if {@code desiredDescription} is not a single test and filters all but the single
+     * test if {@code desiredDescription} is a single test.</p>
+     *
+     * @param desiredDescription {@code Description} of those tests that should be run
+     * @return the filtered Request
+     */
+    public Request filterWith(Description desiredDescription) {
+        return filterWith(Filter.matchMethodDescription(desiredDescription));
+    }
+
+    /**
+     * Returns a Request whose Tests can be run in a certain order, defined by
+     * <code>comparator</code>
+     * <p>
+     * For example, here is code to run a test suite in alphabetical order:
+     * <pre>
+     * private static Comparator&lt;Description&gt; forward() {
+     *   return new Comparator&lt;Description&gt;() {
+     *     public int compare(Description o1, Description o2) {
+     *       return o1.getDisplayName().compareTo(o2.getDisplayName());
+     *     }
+     *   };
+     * }
+     *
+     * public static main() {
+     *   new JUnitCore().run(Request.aClass(AllTests.class).sortWith(forward()));
+     * }
+     * </pre>
+     *
+     * @param comparator definition of the order of the tests in this Request
+     * @return a Request with ordered Tests
+     */
+    public Request sortWith(Comparator<Description> comparator) {
+        return new SortingRequest(this, comparator);
+    }
+
+    /**
+     * Returns a Request whose Tests can be run in a certain order, defined by
+     * <code>ordering</code>
+     * <p>
+     * For example, here is code to run a test suite in reverse order:
+     * <pre>
+     * private static Ordering reverse() {
+     *   return new Ordering() {
+     *     public List&lt;Description&gt; orderItems(Collection&lt;Description&gt; descriptions) {
+     *       List&lt;Description&gt; ordered = new ArrayList&lt;&gt;(descriptions);
+     *       Collections.reverse(ordered);
+     *       return ordered;
+     *     }
+     *   }
+     * }
+     *     
+     * public static main() {
+     *   new JUnitCore().run(Request.aClass(AllTests.class).orderWith(reverse()));
+     * }
+     * </pre>
+     *
+     * @return a Request with ordered Tests
+     * @since 4.13
+     */
+    public Request orderWith(Ordering ordering) {
+        return new OrderingRequest(this, ordering);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/Result.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/Result.java
new file mode 100644
index 0000000..4b5f4a4
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/Result.java
@@ -0,0 +1,217 @@
+package org.junit.runner;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamClass;
+import java.io.ObjectStreamField;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+
+/**
+ * A <code>Result</code> collects and summarizes information from running multiple tests.
+ * All tests are counted -- additional information is collected from tests that fail.
+ *
+ * @since 4.0
+ */
+public class Result implements Serializable {
+    private static final long serialVersionUID = 1L;
+    private static final ObjectStreamField[] serialPersistentFields =
+            ObjectStreamClass.lookup(SerializedForm.class).getFields();
+    private final AtomicInteger count;
+    private final AtomicInteger ignoreCount;
+    private final AtomicInteger assumptionFailureCount;
+    private final CopyOnWriteArrayList<Failure> failures;
+    private final AtomicLong runTime;
+    private final AtomicLong startTime;
+
+    /** Only set during deserialization process. */
+    private SerializedForm serializedForm;
+
+    public Result() {
+        count = new AtomicInteger();
+        ignoreCount = new AtomicInteger();
+        assumptionFailureCount = new AtomicInteger();
+        failures = new CopyOnWriteArrayList<Failure>();
+        runTime = new AtomicLong();
+        startTime = new AtomicLong();
+    }
+
+    private Result(SerializedForm serializedForm) {
+        count = serializedForm.fCount;
+        ignoreCount = serializedForm.fIgnoreCount;
+        assumptionFailureCount = serializedForm.assumptionFailureCount;
+        failures = new CopyOnWriteArrayList<Failure>(serializedForm.fFailures);
+        runTime = new AtomicLong(serializedForm.fRunTime);
+        startTime = new AtomicLong(serializedForm.fStartTime);
+    }
+
+    /**
+     * Returns the number of tests run
+     */
+    public int getRunCount() {
+        return count.get();
+    }
+
+    /**
+     * Returns the number of tests that failed during the run
+     */
+    public int getFailureCount() {
+        return failures.size();
+    }
+
+    /**
+     * Returns the number of milliseconds it took to run the entire suite to run
+     */
+    public long getRunTime() {
+        return runTime.get();
+    }
+
+    /**
+     * Returns the {@link Failure}s describing tests that failed and the problems they encountered
+     */
+    public List<Failure> getFailures() {
+        return failures;
+    }
+
+    /**
+     * @return the number of tests ignored during the run
+     */
+    public int getIgnoreCount() {
+        return ignoreCount.get();
+    }
+
+    /**
+     * Returns the number of tests skipped because of an assumption failure
+     *
+     * @throws UnsupportedOperationException if the result was serialized in a version before JUnit 4.13
+     * @since 4.13
+     */
+    public int getAssumptionFailureCount() {
+        if (assumptionFailureCount == null) {
+            throw new UnsupportedOperationException(
+                    "Result was serialized from a version of JUnit that doesn't support this method");
+        }
+        return assumptionFailureCount.get();
+    }
+
+    /**
+     * @return <code>true</code> if all tests succeeded
+     */
+    public boolean wasSuccessful() {
+        return getFailureCount() == 0;
+    }
+
+    private void writeObject(ObjectOutputStream s) throws IOException {
+        SerializedForm serializedForm = new SerializedForm(this);
+        serializedForm.serialize(s);
+    }
+
+    private void readObject(ObjectInputStream s)
+            throws ClassNotFoundException, IOException {
+        serializedForm = SerializedForm.deserialize(s);
+    }
+
+    private Object readResolve()  {
+        return new Result(serializedForm);
+    }
+
+    @RunListener.ThreadSafe
+    private class Listener extends RunListener {
+        @Override
+        public void testRunStarted(Description description) throws Exception {
+            startTime.set(System.currentTimeMillis());
+        }
+
+        @Override
+        public void testRunFinished(Result result) throws Exception {
+            long endTime = System.currentTimeMillis();
+            runTime.addAndGet(endTime - startTime.get());
+        }
+
+        @Override
+        public void testFinished(Description description) throws Exception {
+            count.getAndIncrement();
+        }
+
+        @Override
+        public void testFailure(Failure failure) throws Exception {
+            failures.add(failure);
+        }
+
+        @Override
+        public void testIgnored(Description description) throws Exception {
+            ignoreCount.getAndIncrement();
+        }
+
+        @Override
+        public void testAssumptionFailure(Failure failure) {
+            assumptionFailureCount.getAndIncrement();
+        }
+    }
+
+    /**
+     * Internal use only.
+     */
+    public RunListener createListener() {
+        return new Listener();
+    }
+
+    /**
+     * Represents the serialized output of {@code Result}. The fields on this
+     * class match the files that {@code Result} had in JUnit 4.11.
+     */
+    private static class SerializedForm implements Serializable {
+        private static final long serialVersionUID = 1L;
+        private final AtomicInteger fCount;
+        private final AtomicInteger fIgnoreCount;
+        private final AtomicInteger assumptionFailureCount;
+        private final List<Failure> fFailures;
+        private final long fRunTime;
+        private final long fStartTime;
+
+        public SerializedForm(Result result) {
+            fCount = result.count;
+            fIgnoreCount = result.ignoreCount;
+            assumptionFailureCount = result.assumptionFailureCount;
+            fFailures = Collections.synchronizedList(new ArrayList<Failure>(result.failures));
+            fRunTime = result.runTime.longValue();
+            fStartTime = result.startTime.longValue();
+        }
+
+        @SuppressWarnings("unchecked")
+        private SerializedForm(ObjectInputStream.GetField fields) throws IOException {
+            fCount = (AtomicInteger) fields.get("fCount", null);
+            fIgnoreCount = (AtomicInteger) fields.get("fIgnoreCount", null);
+            assumptionFailureCount = (AtomicInteger) fields.get("assumptionFailureCount", null);
+            fFailures = (List<Failure>) fields.get("fFailures", null);
+            fRunTime = fields.get("fRunTime", 0L);
+            fStartTime = fields.get("fStartTime", 0L);
+        }
+
+        public void serialize(ObjectOutputStream s) throws IOException {
+            ObjectOutputStream.PutField fields = s.putFields();
+            fields.put("fCount", fCount);
+            fields.put("fIgnoreCount", fIgnoreCount);
+            fields.put("fFailures", fFailures);
+            fields.put("fRunTime", fRunTime);
+            fields.put("fStartTime", fStartTime);
+            fields.put("assumptionFailureCount", assumptionFailureCount);
+            s.writeFields();
+        }
+
+        public static SerializedForm deserialize(ObjectInputStream s)
+                throws ClassNotFoundException, IOException {
+            ObjectInputStream.GetField fields = s.readFields();
+            return new SerializedForm(fields);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/RunWith.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/RunWith.java
new file mode 100644
index 0000000..3428ee2
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/RunWith.java
@@ -0,0 +1,36 @@
+package org.junit.runner;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * When a class is annotated with <code>&#064;RunWith</code> or extends a class annotated
+ * with <code>&#064;RunWith</code>, JUnit will invoke the class it references to run the
+ * tests in that class instead of the runner built into JUnit. We added this feature late
+ * in development. While it seems powerful we expect the runner API to change as we learn
+ * how people really use it. Some of the classes that are currently internal will likely
+ * be refined and become public.
+ *
+ * For example, suites in JUnit 4 are built using RunWith, and a custom runner named Suite:
+ *
+ * <pre>
+ * &#064;RunWith(Suite.class)
+ * &#064;SuiteClasses({ATest.class, BTest.class, CTest.class})
+ * public class ABCSuite {
+ * }
+ * </pre>
+ *
+ * @since 4.0
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface RunWith {
+    /**
+     * @return a Runner class (must have a constructor that takes a single Class to run)
+     */
+    Class<? extends Runner> value();
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/Runner.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/Runner.java
new file mode 100644
index 0000000..d728dd8
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/Runner.java
@@ -0,0 +1,43 @@
+package org.junit.runner;
+
+import org.junit.runner.notification.RunNotifier;
+
+/**
+ * A <code>Runner</code> runs tests and notifies a {@link org.junit.runner.notification.RunNotifier}
+ * of significant events as it does so. You will need to subclass <code>Runner</code>
+ * when using {@link org.junit.runner.RunWith} to invoke a custom runner. When creating
+ * a custom runner, in addition to implementing the abstract methods here you must
+ * also provide a constructor that takes as an argument the {@link Class} containing
+ * the tests.
+ *
+ * <p>The default runner implementation guarantees that the instances of the test case
+ * class will be constructed immediately before running the test and that the runner
+ * will retain no reference to the test case instances, generally making them
+ * available for garbage collection.
+ *
+ * @see org.junit.runner.Description
+ * @see org.junit.runner.RunWith
+ * @since 4.0
+ */
+public abstract class Runner implements Describable {
+    /*
+     * (non-Javadoc)
+     * @see org.junit.runner.Describable#getDescription()
+     */
+    public abstract Description getDescription();
+
+    /**
+     * Run the tests for this runner.
+     *
+     * @param notifier will be notified of events while tests are being run--tests being
+     * started, finishing, and failing
+     */
+    public abstract void run(RunNotifier notifier);
+
+    /**
+     * @return the number of tests to be run by the receiver
+     */
+    public int testCount() {
+        return getDescription().testCount();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Alphanumeric.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Alphanumeric.java
new file mode 100644
index 0000000..8388d21
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Alphanumeric.java
@@ -0,0 +1,27 @@
+package org.junit.runner.manipulation;
+
+import java.util.Comparator;
+
+import org.junit.runner.Description;
+
+/**
+ * A sorter that orders tests alphanumerically by test name.
+ *
+ * @since 4.13
+ */
+public final class Alphanumeric extends Sorter implements Ordering.Factory {
+
+    public Alphanumeric() {
+        super(COMPARATOR);
+    }
+
+    public Ordering create(Context context) {
+        return this;
+    }
+
+    private static final Comparator<Description> COMPARATOR = new Comparator<Description>() {
+        public int compare(Description o1, Description o2) {
+            return o1.getDisplayName().compareTo(o2.getDisplayName());
+        }
+    };
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Filter.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Filter.java
new file mode 100644
index 0000000..0287351
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Filter.java
@@ -0,0 +1,122 @@
+package org.junit.runner.manipulation;
+
+import org.junit.runner.Description;
+import org.junit.runner.Request;
+
+/**
+ * The canonical case of filtering is when you want to run a single test method in a class. Rather
+ * than introduce runner API just for that one case, JUnit provides a general filtering mechanism.
+ * If you want to filter the tests to be run, extend <code>Filter</code> and apply an instance of
+ * your filter to the {@link org.junit.runner.Request} before running it (see
+ * {@link org.junit.runner.JUnitCore#run(Request)}. Alternatively, apply a <code>Filter</code> to
+ * a {@link org.junit.runner.Runner} before running tests (for example, in conjunction with
+ * {@link org.junit.runner.RunWith}.
+ *
+ * @since 4.0
+ */
+public abstract class Filter {
+    /**
+     * A null <code>Filter</code> that passes all tests through.
+     */
+    public static final Filter ALL = new Filter() {
+        @Override
+        public boolean shouldRun(Description description) {
+            return true;
+        }
+
+        @Override
+        public String describe() {
+            return "all tests";
+        }
+
+        @Override
+        public void apply(Object child) throws NoTestsRemainException {
+            // do nothing
+        }
+
+        @Override
+        public Filter intersect(Filter second) {
+            return second;
+        }
+    };
+
+    /**
+     * Returns a {@code Filter} that only runs the single method described by
+     * {@code desiredDescription}
+     */
+    public static Filter matchMethodDescription(final Description desiredDescription) {
+        return new Filter() {
+            @Override
+            public boolean shouldRun(Description description) {
+                if (description.isTest()) {
+                    return desiredDescription.equals(description);
+                }
+
+                // explicitly check if any children want to run
+                for (Description each : description.getChildren()) {
+                    if (shouldRun(each)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            @Override
+            public String describe() {
+                return String.format("Method %s", desiredDescription.getDisplayName());
+            }
+        };
+    }
+
+
+    /**
+     * @param description the description of the test to be run
+     * @return <code>true</code> if the test should be run
+     */
+    public abstract boolean shouldRun(Description description);
+
+    /**
+     * Returns a textual description of this Filter
+     *
+     * @return a textual description of this Filter
+     */
+    public abstract String describe();
+
+    /**
+     * Invoke with a {@link org.junit.runner.Runner} to cause all tests it intends to run
+     * to first be checked with the filter. Only those that pass the filter will be run.
+     *
+     * @param child the runner to be filtered by the receiver
+     * @throws NoTestsRemainException if the receiver removes all tests
+     */
+    public void apply(Object child) throws NoTestsRemainException {
+        if (!(child instanceof Filterable)) {
+            return;
+        }
+        Filterable filterable = (Filterable) child;
+        filterable.filter(this);
+    }
+
+    /**
+     * Returns a new Filter that accepts the intersection of the tests accepted
+     * by this Filter and {@code second}
+     */
+    public Filter intersect(final Filter second) {
+        if (second == this || second == ALL) {
+            return this;
+        }
+        final Filter first = this;
+        return new Filter() {
+            @Override
+            public boolean shouldRun(Description description) {
+                return first.shouldRun(description)
+                        && second.shouldRun(description);
+            }
+
+            @Override
+            public String describe() {
+                return first.describe() + " and " + second.describe();
+            }
+        };
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Filterable.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Filterable.java
new file mode 100644
index 0000000..d605027
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Filterable.java
@@ -0,0 +1,19 @@
+package org.junit.runner.manipulation;
+
+/**
+ * Runners that allow filtering should implement this interface. Implement {@link #filter(Filter)}
+ * to remove tests that don't pass the filter.
+ *
+ * @since 4.0
+ */
+public interface Filterable {
+
+    /**
+     * Remove tests that don't pass the parameter <code>filter</code>.
+     *
+     * @param filter the {@link Filter} to apply
+     * @throws NoTestsRemainException if all tests are filtered out
+     */
+    void filter(Filter filter) throws NoTestsRemainException;
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/InvalidOrderingException.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/InvalidOrderingException.java
new file mode 100644
index 0000000..d9d60f7
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/InvalidOrderingException.java
@@ -0,0 +1,21 @@
+package org.junit.runner.manipulation;
+
+/**
+ * Thrown when an ordering does something invalid (like remove or add children)
+ *
+ * @since 4.13
+ */
+public class InvalidOrderingException extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    public InvalidOrderingException() {
+    }
+
+    public InvalidOrderingException(String message) {
+        super(message);
+    }
+
+    public InvalidOrderingException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/NoTestsRemainException.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/NoTestsRemainException.java
new file mode 100644
index 0000000..21935bd
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/NoTestsRemainException.java
@@ -0,0 +1,10 @@
+package org.junit.runner.manipulation;
+
+/**
+ * Thrown when a filter removes all tests from a runner.
+ *
+ * @since 4.0
+ */
+public class NoTestsRemainException extends Exception {
+    private static final long serialVersionUID = 1L;
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Orderable.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Orderable.java
new file mode 100644
index 0000000..9a12a3b
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Orderable.java
@@ -0,0 +1,21 @@
+package org.junit.runner.manipulation;
+
+/**
+ * Interface for runners that allow ordering of tests.
+ *
+ * <p>Beware of using this interface to cope with order dependencies between tests.
+ * Tests that are isolated from each other are less expensive to maintain and
+ * can be run individually.
+ *
+ * @since 4.13
+ */
+public interface Orderable extends Sortable {
+
+    /**
+     * Orders the tests using <code>orderer</code>
+     *
+     * @throws InvalidOrderingException if orderer does something invalid (like remove or add
+     * children)
+     */
+    void order(Orderer orderer) throws InvalidOrderingException;
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Orderer.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Orderer.java
new file mode 100644
index 0000000..eb13054
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Orderer.java
@@ -0,0 +1,62 @@
+package org.junit.runner.manipulation;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.runner.Description;
+
+/**
+ * Orders tests.
+ *
+ * @since 4.13
+ */
+public final class Orderer  {
+    private final Ordering ordering;
+
+    Orderer(Ordering delegate) {
+        this.ordering = delegate;
+    }
+
+    /**
+     * Orders the descriptions.
+     *
+     * @return descriptions in order
+     */
+    public List<Description> order(Collection<Description> descriptions)
+            throws InvalidOrderingException {
+        List<Description> inOrder = ordering.orderItems(
+                Collections.unmodifiableCollection(descriptions));
+        if (!ordering.validateOrderingIsCorrect()) {
+            return inOrder;
+        }
+
+        Set<Description> uniqueDescriptions = new HashSet<Description>(descriptions);
+        if (!uniqueDescriptions.containsAll(inOrder)) {
+            throw new InvalidOrderingException("Ordering added items");
+        }
+        Set<Description> resultAsSet = new HashSet<Description>(inOrder);
+        if (resultAsSet.size() != inOrder.size()) {
+            throw new InvalidOrderingException("Ordering duplicated items");
+        } else if (!resultAsSet.containsAll(uniqueDescriptions)) {
+            throw new InvalidOrderingException("Ordering removed items");
+        }
+
+        return inOrder;
+    }
+
+    /**
+     * Order the tests in <code>target</code>.
+     *
+     * @throws InvalidOrderingException if ordering does something invalid (like remove or add
+     * children)
+     */
+    public void apply(Object target) throws InvalidOrderingException {
+        if (target instanceof Orderable) {
+            Orderable orderable = (Orderable) target;
+            orderable.order(this);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Ordering.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Ordering.java
new file mode 100644
index 0000000..0d0ce93
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Ordering.java
@@ -0,0 +1,172 @@
+package org.junit.runner.manipulation;
+
+import java.lang.reflect.Constructor;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+import org.junit.runner.Description;
+import org.junit.runner.OrderWith;
+
+/**
+ * Reorders tests. An {@code Ordering} can reverse the order of tests, sort the
+ * order or even shuffle the order.
+ *
+ * <p>In general you will not need to use a <code>Ordering</code> directly.
+ * Instead, use {@link org.junit.runner.Request#orderWith(Ordering)}.
+ *
+ * @since 4.13
+ */
+public abstract class Ordering {
+    private static final String CONSTRUCTOR_ERROR_FORMAT
+            = "Ordering class %s should have a public constructor with signature "
+                    + "%s(Ordering.Context context)";
+
+    /**
+     * Creates an {@link Ordering} that shuffles the items using the given
+     * {@link Random} instance.
+     */
+    public static Ordering shuffledBy(final Random random) {
+        return new Ordering() {
+            @Override
+            boolean validateOrderingIsCorrect() {
+                return false;
+            }
+
+            @Override
+            protected List<Description> orderItems(Collection<Description> descriptions) {
+                List<Description> shuffled = new ArrayList<Description>(descriptions);
+                Collections.shuffle(shuffled, random);
+                return shuffled;
+            }
+        };
+    }
+
+    /**
+     * Creates an {@link Ordering} from the given factory class. The class must have a public no-arg
+     * constructor.
+     *
+     * @param factoryClass class to use to create the ordering
+     * @param annotatedTestClass test class that is annotated with {@link OrderWith}.
+     * @throws InvalidOrderingException if the instance could not be created
+     */
+    public static Ordering definedBy(
+            Class<? extends Ordering.Factory> factoryClass, Description annotatedTestClass)
+            throws InvalidOrderingException {
+        if (factoryClass == null) {
+            throw new NullPointerException("factoryClass cannot be null");
+        }
+        if (annotatedTestClass == null) {
+            throw new NullPointerException("annotatedTestClass cannot be null");
+        }
+
+        Ordering.Factory factory;
+        try {
+            Constructor<? extends Ordering.Factory> constructor = factoryClass.getConstructor();
+            factory = constructor.newInstance();
+        } catch (NoSuchMethodException e) {
+            throw new InvalidOrderingException(String.format(
+                    CONSTRUCTOR_ERROR_FORMAT,
+                    getClassName(factoryClass),
+                    factoryClass.getSimpleName()));
+        } catch (Exception e) {
+            throw new InvalidOrderingException(
+                    "Could not create ordering for " + annotatedTestClass, e);
+        }
+        return definedBy(factory, annotatedTestClass);
+    }
+
+    /**
+     * Creates an {@link Ordering} from the given factory.
+     *
+     * @param factory factory to use to create the ordering
+     * @param annotatedTestClass test class that is annotated with {@link OrderWith}.
+     * @throws InvalidOrderingException if the instance could not be created
+     */
+    public static Ordering definedBy(
+            Ordering.Factory factory, Description annotatedTestClass)
+            throws InvalidOrderingException {
+        if (factory == null) {
+            throw new NullPointerException("factory cannot be null");
+        }
+        if (annotatedTestClass == null) {
+            throw new NullPointerException("annotatedTestClass cannot be null");
+        }
+
+        return factory.create(new Ordering.Context(annotatedTestClass));
+    }
+
+    private static String getClassName(Class<?> clazz) {
+        String name = clazz.getCanonicalName();
+        if (name == null) {
+            return clazz.getName();
+        }
+        return name;
+    }
+
+    /**
+     * Order the tests in <code>target</code> using this ordering.
+     *
+     * @throws InvalidOrderingException if ordering does something invalid (like remove or add
+     * children)
+     */
+    public void apply(Object target) throws InvalidOrderingException {
+        /*
+         * Note that some subclasses of Ordering override apply(). The Sorter
+         * subclass of Ordering overrides apply() to apply the sort (this is
+         * done because sorting is more efficient than ordering).
+         */
+        if (target instanceof Orderable) {
+            Orderable orderable = (Orderable) target;
+            orderable.order(new Orderer(this));
+        }
+    }
+
+    /**
+     * Returns {@code true} if this ordering could produce invalid results (i.e.
+     * if it could add or remove values).
+     */
+    boolean validateOrderingIsCorrect() {
+        return true;
+    }
+
+    /**
+     * Implemented by sub-classes to order the descriptions.
+     *
+     * @return descriptions in order
+     */
+    protected abstract List<Description> orderItems(Collection<Description> descriptions);
+
+    /** Context about the ordering being applied. */
+    public static class Context {
+        private final Description description;
+
+        /**
+         * Gets the description for the top-level target being ordered.
+         */
+        public Description getTarget() {
+            return description;
+        }
+
+        private Context(Description description) {
+            this.description = description;
+        }
+    }
+
+    /**
+     * Factory for creating {@link Ordering} instances.
+     *
+     * <p>For a factory to be used with {@code @OrderWith} it needs to have a public no-arg
+     * constructor.
+     */
+    public interface Factory {
+        /**
+         * Creates an Ordering instance using the given context. Implementations
+         * of this method that do not need to use the context can return the
+         * same instance every time.
+         */
+        Ordering create(Context context);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Sortable.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Sortable.java
new file mode 100644
index 0000000..0c59f33
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Sortable.java
@@ -0,0 +1,20 @@
+package org.junit.runner.manipulation;
+
+/**
+ * Interface for runners that allow sorting of tests. By sorting tests based on when they last failed, most recently
+ * failed first, you can reduce the average time to the first test failing. Test sorting should not be used to
+ * cope with order dependencies between tests. Tests that are isolated from each other are less
+ * expensive to maintain and can be run individually.
+ *
+ * @since 4.0
+ */
+public interface Sortable {
+
+    /**
+     * Sorts the tests using <code>sorter</code>
+     *
+     * @param sorter the {@link Sorter} to use for sorting the tests
+     */
+    void sort(Sorter sorter);
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Sorter.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Sorter.java
new file mode 100644
index 0000000..4b5274c
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/Sorter.java
@@ -0,0 +1,90 @@
+package org.junit.runner.manipulation;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.junit.runner.Description;
+
+/**
+ * A <code>Sorter</code> orders tests. In general you will not need
+ * to use a <code>Sorter</code> directly. Instead, use
+ * {@link org.junit.runner.Request#sortWith(Comparator)}.
+ *
+ * @since 4.0
+ */
+public class Sorter extends Ordering implements Comparator<Description> {
+    /**
+     * NULL is a <code>Sorter</code> that leaves elements in an undefined order
+     */
+    public static final Sorter NULL = new Sorter(new Comparator<Description>() {
+        public int compare(Description o1, Description o2) {
+            return 0;
+        }
+    });
+
+    private final Comparator<Description> comparator;
+
+    /**
+     * Creates a <code>Sorter</code> that uses <code>comparator</code>
+     * to sort tests
+     *
+     * @param comparator the {@link Comparator} to use when sorting tests
+     * @since 4.0
+     */
+    public Sorter(Comparator<Description> comparator) {
+        this.comparator = comparator;
+    }
+
+    /**
+     * Sorts the tests in <code>target</code> using <code>comparator</code>.
+     *
+     * @since 4.0
+     */
+    @Override
+    public void apply(Object target) {
+        /*
+         * Note that all runners that are Orderable are also Sortable (because
+         * Orderable extends Sortable). Sorting is more efficient than ordering,
+         * so we override the parent behavior so we sort instead.
+         */
+        if (target instanceof Sortable) {
+            Sortable sortable = (Sortable) target;
+            sortable.sort(this);
+        }
+    }
+
+    public int compare(Description o1, Description o2) {
+        return comparator.compare(o1, o2);
+    }
+ 
+    /**
+     * {@inheritDoc}
+     *
+     * @since 4.13
+     */
+    @Override
+    protected final List<Description> orderItems(Collection<Description> descriptions) {
+        /*
+         * In practice, we will never get here--Sorters do their work in the
+         * compare() method--but the Liskov substitution principle demands that
+         * we obey the general contract of Orderable. Luckily, it's trivial to
+         * implement.
+         */
+        List<Description> sorted = new ArrayList<Description>(descriptions);
+        Collections.sort(sorted, this); // Note: it would be incorrect to pass in "comparator"
+        return sorted;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @since 4.13
+     */
+    @Override
+    boolean validateOrderingIsCorrect() {
+        return false;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/package-info.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/package-info.java
new file mode 100644
index 0000000..ba5c3b2
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/manipulation/package-info.java
@@ -0,0 +1,7 @@
+/**
+ * Provides classes to {@link org.junit.runner.manipulation.Filter filter} or {@link org.junit.runner.manipulation.Sorter sort} tests.
+ *
+ * @since 4.0
+ * @see org.junit.runner.Runner
+ */
+package org.junit.runner.manipulation;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/Failure.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/Failure.java
new file mode 100644
index 0000000..4551302
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/Failure.java
@@ -0,0 +1,90 @@
+package org.junit.runner.notification;
+
+import java.io.Serializable;
+
+import org.junit.internal.Throwables;
+import org.junit.runner.Description;
+
+/**
+ * A <code>Failure</code> holds a description of the failed test and the
+ * exception that was thrown while running it. In most cases the {@link org.junit.runner.Description}
+ * will be of a single test. However, if problems are encountered while constructing the
+ * test (for example, if a {@link org.junit.BeforeClass} method is not static), it may describe
+ * something other than a single test.
+ *
+ * @since 4.0
+ */
+public class Failure implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit4/issues/976
+     */
+    private final Description fDescription;
+    private final Throwable fThrownException;
+
+    /**
+     * Constructs a <code>Failure</code> with the given description and exception.
+     *
+     * @param description a {@link org.junit.runner.Description} of the test that failed
+     * @param thrownException the exception that was thrown while running the test
+     */
+    public Failure(Description description, Throwable thrownException) {
+        this.fThrownException = thrownException;
+        this.fDescription = description;
+    }
+
+    /**
+     * @return a user-understandable label for the test
+     */
+    public String getTestHeader() {
+        return fDescription.getDisplayName();
+    }
+
+    /**
+     * @return the raw description of the context of the failure.
+     */
+    public Description getDescription() {
+        return fDescription;
+    }
+
+    /**
+     * @return the exception thrown
+     */
+
+    public Throwable getException() {
+        return fThrownException;
+    }
+
+    @Override
+    public String toString() {
+        return getTestHeader() + ": " + fThrownException.getMessage();
+    }
+
+    /**
+     * Gets the printed form of the exception and its stack trace.
+     */
+    public String getTrace() {
+        return Throwables.getStacktrace(getException());
+    }
+
+    /**
+     * Gets a the printed form of the exception, with a trimmed version of the stack trace.
+     * This method will attempt to filter out frames of the stack trace that are below
+     * the test method call.
+     */
+    public String getTrimmedTrace() {
+        return Throwables.getTrimmedStackTrace(getException());
+    }
+
+    /**
+     * Convenience method
+     *
+     * @return the message of the thrown exception
+     */
+    public String getMessage() {
+        return getException().getMessage();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/RunListener.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/RunListener.java
new file mode 100644
index 0000000..d7cac00
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/RunListener.java
@@ -0,0 +1,168 @@
+package org.junit.runner.notification;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+
+/**
+ * Register an instance of this class with {@link RunNotifier} to be notified
+ * of events that occur during a test run. All of the methods in this class
+ * are abstract and have no implementation; override one or more methods to
+ * receive events.
+ * <p>
+ * For example, suppose you have a <code>Cowbell</code>
+ * class that you want to make a noise whenever a test fails. You could write:
+ * <pre>
+ * public class RingingListener extends RunListener {
+ *    public void testFailure(Failure failure) {
+ *       Cowbell.ring();
+ *    }
+ * }
+ * </pre>
+ * <p>
+ * To invoke your listener, you need to run your tests through <code>JUnitCore</code>.
+ * <pre>
+ * public void main(String... args) {
+ *    JUnitCore core= new JUnitCore();
+ *    core.addListener(new RingingListener());
+ *    core.run(MyTestClass.class);
+ * }
+ * </pre>
+ * <p>
+ * If a listener throws an exception for a test event, the other listeners will
+ * have their {@link RunListener#testFailure(Failure)} called with a {@code Description}
+ * of {@link Description#TEST_MECHANISM} to indicate the failure.
+ * <p>
+ * By default, JUnit will synchronize calls to your listener. If your listener
+ * is thread-safe and you want to allow JUnit to call your listener from
+ * multiple threads when tests are run in parallel, you can annotate your
+ * test class with {@link RunListener.ThreadSafe}.
+ * <p>
+ * Listener methods will be called from the same thread as is running
+ * the test, unless otherwise indicated by the method Javadoc
+ *
+ * @see org.junit.runner.JUnitCore
+ * @since 4.0
+ */
+public class RunListener {
+
+    /**
+     * Called before any tests have been run. This may be called on an
+     * arbitrary thread.
+     *
+     * @param description describes the tests to be run
+     */
+    public void testRunStarted(Description description) throws Exception {
+    }
+
+    /**
+     * Called when all tests have finished. This may be called on an
+     * arbitrary thread.
+     *
+     * @param result the summary of the test run, including all the tests that failed
+     */
+    public void testRunFinished(Result result) throws Exception {
+    }
+
+    /**
+     * Called when a test suite is about to be started. If this method is
+     * called for a given {@link Description}, then {@link #testSuiteFinished(Description)}
+     * will also be called for the same {@code Description}.
+     *
+     * <p>Note that not all runners will call this method, so runners should
+     * be prepared to handle {@link #testStarted(Description)} calls for tests
+     * where there was no corresponding {@code testSuiteStarted()} call for
+     * the parent {@code Description}.
+     *
+     * @param description the description of the test suite that is about to be run
+     *                    (generally a class name)
+     * @since 4.13
+     */
+    public void testSuiteStarted(Description description) throws Exception {
+    }
+
+    /**
+     * Called when a test suite has finished, whether the test suite succeeds or fails.
+     * This method will not be called for a given {@link Description} unless
+     * {@link #testSuiteStarted(Description)} was called for the same @code Description}.
+     *
+     * @param description the description of the test suite that just ran
+     * @since 4.13
+     */
+    public void testSuiteFinished(Description description) throws Exception {
+    }
+
+    /**
+     * Called when an atomic test is about to be started.
+     *
+     * @param description the description of the test that is about to be run
+     * (generally a class and method name)
+     */
+    public void testStarted(Description description) throws Exception {
+    }
+
+    /**
+     * Called when an atomic test has finished, whether the test succeeds or fails.
+     *
+     * @param description the description of the test that just ran
+     */
+    public void testFinished(Description description) throws Exception {
+    }
+
+    /**
+     * Called when an atomic test fails, or when a listener throws an exception.
+     *
+     * <p>In the case of a failure of an atomic test, this method will be called
+     * with the same {@code Description} passed to
+     * {@link #testStarted(Description)}, from the same thread that called
+     * {@link #testStarted(Description)}.
+     *
+     * <p>In the case of a listener throwing an exception, this will be called with
+     * a {@code Description} of {@link Description#TEST_MECHANISM}, and may be called
+     * on an arbitrary thread.
+     *
+     * @param failure describes the test that failed and the exception that was thrown
+     */
+    public void testFailure(Failure failure) throws Exception {
+    }
+
+    /**
+     * Called when an atomic test flags that it assumes a condition that is
+     * false
+     *
+     * @param failure describes the test that failed and the
+     * {@link org.junit.AssumptionViolatedException} that was thrown
+     */
+    public void testAssumptionFailure(Failure failure) {
+    }
+
+    /**
+     * Called when a test will not be run, generally because a test method is annotated
+     * with {@link org.junit.Ignore}.
+     *
+     * @param description describes the test that will not be run
+     */
+    public void testIgnored(Description description) throws Exception {
+    }
+
+
+    /**
+     * Indicates a {@code RunListener} that can have its methods called
+     * concurrently. This implies that the class is thread-safe (i.e. no set of
+     * listener calls can put the listener into an invalid state, even if those
+     * listener calls are being made by multiple threads without
+     * synchronization).
+     *
+     * @since 4.12
+     */
+    @Documented
+    @Target(ElementType.TYPE)
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface ThreadSafe {
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/RunNotifier.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/RunNotifier.java
new file mode 100644
index 0000000..752fa3b
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/RunNotifier.java
@@ -0,0 +1,249 @@
+package org.junit.runner.notification;
+
+import static java.util.Arrays.asList;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+
+/**
+ * If you write custom runners, you may need to notify JUnit of your progress running tests.
+ * Do this by invoking the <code>RunNotifier</code> passed to your implementation of
+ * {@link org.junit.runner.Runner#run(RunNotifier)}. Future evolution of this class is likely to
+ * move {@link #fireTestRunStarted(Description)} and {@link #fireTestRunFinished(Result)}
+ * to a separate class since they should only be called once per run.
+ *
+ * @since 4.0
+ */
+public class RunNotifier {
+    private final List<RunListener> listeners = new CopyOnWriteArrayList<RunListener>();
+    private volatile boolean pleaseStop = false;
+
+    /**
+     * Internal use only
+     */
+    public void addListener(RunListener listener) {
+        if (listener == null) {
+            throw new NullPointerException("Cannot add a null listener");
+        }
+        listeners.add(wrapIfNotThreadSafe(listener));
+    }
+
+    /**
+     * Internal use only
+     */
+    public void removeListener(RunListener listener) {
+        if (listener == null) {
+            throw new NullPointerException("Cannot remove a null listener");
+        }
+        listeners.remove(wrapIfNotThreadSafe(listener));
+    }
+
+    /**
+     * Wraps the given listener with {@link SynchronizedRunListener} if
+     * it is not annotated with {@link RunListener.ThreadSafe}.
+     */
+    RunListener wrapIfNotThreadSafe(RunListener listener) {
+        return listener.getClass().isAnnotationPresent(RunListener.ThreadSafe.class) ?
+                listener : new SynchronizedRunListener(listener, this);
+    }
+
+
+    private abstract class SafeNotifier {
+        private final List<RunListener> currentListeners;
+
+        SafeNotifier() {
+            this(listeners);
+        }
+
+        SafeNotifier(List<RunListener> currentListeners) {
+            this.currentListeners = currentListeners;
+        }
+
+        void run() {
+            int capacity = currentListeners.size();
+            List<RunListener> safeListeners = new ArrayList<RunListener>(capacity);
+            List<Failure> failures = new ArrayList<Failure>(capacity);
+            for (RunListener listener : currentListeners) {
+                try {
+                    notifyListener(listener);
+                    safeListeners.add(listener);
+                } catch (Exception e) {
+                    failures.add(new Failure(Description.TEST_MECHANISM, e));
+                }
+            }
+            fireTestFailures(safeListeners, failures);
+        }
+
+        protected abstract void notifyListener(RunListener each) throws Exception;
+    }
+
+    /**
+     * Do not invoke.
+     */
+    public void fireTestRunStarted(final Description description) {
+        new SafeNotifier() {
+            @Override
+            protected void notifyListener(RunListener each) throws Exception {
+                each.testRunStarted(description);
+            }
+        }.run();
+    }
+
+    /**
+     * Do not invoke.
+     */
+    public void fireTestRunFinished(final Result result) {
+        new SafeNotifier() {
+            @Override
+            protected void notifyListener(RunListener each) throws Exception {
+                each.testRunFinished(result);
+            }
+        }.run();
+    }
+
+    /**
+     * Invoke to tell listeners that a test suite is about to start. Runners are strongly
+     * encouraged--but not required--to call this method. If this method is called for
+     * a given {@link Description} then {@link #fireTestSuiteFinished(Description)} MUST
+     * be called for the same {@code Description}.
+     *
+     * @param description the description of the suite test (generally a class name)
+     * @since 4.13
+     */
+    public void fireTestSuiteStarted(final Description description) {
+        new SafeNotifier() {
+            @Override
+            protected void notifyListener(RunListener each) throws Exception {
+                each.testSuiteStarted(description);
+            }
+        }.run();
+    }
+
+    /**
+     * Invoke to tell listeners that a test suite is about to finish. Always invoke
+     * this method if you invoke {@link #fireTestSuiteStarted(Description)}
+     * as listeners are likely to expect them to come in pairs.
+     *
+     * @param description the description of the suite test (generally a class name)
+     * @since 4.13
+     */
+    public void fireTestSuiteFinished(final Description description) {
+        new SafeNotifier() {
+            @Override
+            protected void notifyListener(RunListener each) throws Exception {
+                each.testSuiteFinished(description);
+            }
+        }.run();
+    }
+
+    /**
+     * Invoke to tell listeners that an atomic test is about to start.
+     *
+     * @param description the description of the atomic test (generally a class and method name)
+     * @throws StoppedByUserException thrown if a user has requested that the test run stop
+     */
+    public void fireTestStarted(final Description description) throws StoppedByUserException {
+        if (pleaseStop) {
+            throw new StoppedByUserException();
+        }
+        new SafeNotifier() {
+            @Override
+            protected void notifyListener(RunListener each) throws Exception {
+                each.testStarted(description);
+            }
+        }.run();
+    }
+
+    /**
+     * Invoke to tell listeners that an atomic test failed.
+     *
+     * @param failure the description of the test that failed and the exception thrown
+     */
+    public void fireTestFailure(Failure failure) {
+        fireTestFailures(listeners, asList(failure));
+    }
+
+    private void fireTestFailures(List<RunListener> listeners,
+            final List<Failure> failures) {
+        if (!failures.isEmpty()) {
+            new SafeNotifier(listeners) {
+                @Override
+                protected void notifyListener(RunListener listener) throws Exception {
+                    for (Failure each : failures) {
+                        listener.testFailure(each);
+                    }
+                }
+            }.run();
+        }
+    }
+
+    /**
+     * Invoke to tell listeners that an atomic test flagged that it assumed
+     * something false.
+     *
+     * @param failure the description of the test that failed and the
+     * {@link org.junit.AssumptionViolatedException} thrown
+     */
+    public void fireTestAssumptionFailed(final Failure failure) {
+        new SafeNotifier() {
+            @Override
+            protected void notifyListener(RunListener each) throws Exception {
+                each.testAssumptionFailure(failure);
+            }
+        }.run();
+    }
+
+    /**
+     * Invoke to tell listeners that an atomic test was ignored.
+     *
+     * @param description the description of the ignored test
+     */
+    public void fireTestIgnored(final Description description) {
+        new SafeNotifier() {
+            @Override
+            protected void notifyListener(RunListener each) throws Exception {
+                each.testIgnored(description);
+            }
+        }.run();
+    }
+
+    /**
+     * Invoke to tell listeners that an atomic test finished. Always invoke
+     * this method if you invoke {@link #fireTestStarted(Description)}
+     * as listeners are likely to expect them to come in pairs.
+     *
+     * @param description the description of the test that finished
+     */
+    public void fireTestFinished(final Description description) {
+        new SafeNotifier() {
+            @Override
+            protected void notifyListener(RunListener each) throws Exception {
+                each.testFinished(description);
+            }
+        }.run();
+    }
+
+    /**
+     * Ask that the tests run stop before starting the next test. Phrased politely because
+     * the test currently running will not be interrupted. It seems a little odd to put this
+     * functionality here, but the <code>RunNotifier</code> is the only object guaranteed
+     * to be shared amongst the many runners involved.
+     */
+    public void pleaseStop() {
+        pleaseStop = true;
+    }
+
+    /**
+     * Internal use only. The Result's listener must be first.
+     */
+    public void addFirstListener(RunListener listener) {
+        if (listener == null) {
+            throw new NullPointerException("Cannot add a null listener");
+        }
+        listeners.add(0, wrapIfNotThreadSafe(listener));
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/StoppedByUserException.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/StoppedByUserException.java
new file mode 100644
index 0000000..f5490f7
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/StoppedByUserException.java
@@ -0,0 +1,12 @@
+package org.junit.runner.notification;
+
+/**
+ * Thrown when a user has requested that the test run stop. Writers of
+ * test running GUIs should be prepared to catch a <code>StoppedByUserException</code>.
+ *
+ * @see org.junit.runner.notification.RunNotifier
+ * @since 4.0
+ */
+public class StoppedByUserException extends RuntimeException {
+    private static final long serialVersionUID = 1L;
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/SynchronizedRunListener.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/SynchronizedRunListener.java
new file mode 100644
index 0000000..400fed8
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/SynchronizedRunListener.java
@@ -0,0 +1,134 @@
+package org.junit.runner.notification;
+
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+
+/**
+ * Thread-safe decorator for {@link RunListener} implementations that synchronizes
+ * calls to the delegate.
+ *
+ * <p>This class synchronizes all listener calls on a RunNotifier instance. This is done because
+ * prior to JUnit 4.12, all listeners were called in a synchronized block in RunNotifier,
+ * so no two listeners were ever called concurrently. If we instead made the methods here
+ * synchronized, clients that added multiple listeners that called common code might see
+ * issues due to the reduced synchronization.
+ *
+ * @author Tibor Digana (tibor17)
+ * @author Kevin Cooney (kcooney)
+ * @since 4.12
+ *
+ * @see RunNotifier
+ */
+@RunListener.ThreadSafe
+final class SynchronizedRunListener extends RunListener {
+    private final RunListener listener;
+    private final Object monitor;
+
+    SynchronizedRunListener(RunListener listener, Object monitor) {
+        this.listener = listener;
+        this.monitor = monitor;
+    }
+
+    @Override
+    public void testRunStarted(Description description) throws Exception {
+        synchronized (monitor) {
+            listener.testRunStarted(description);
+        }
+    }
+
+    @Override
+    public void testRunFinished(Result result) throws Exception {
+        synchronized (monitor) {
+            listener.testRunFinished(result);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p/>
+     * Synchronized decorator for {@link RunListener#testSuiteStarted(Description)}.
+     * @param description the description of the test suite that is about to be run
+     *                    (generally a class name).
+     * @throws Exception if any occurs.
+     * @since 4.13
+     */
+    @Override
+    public void testSuiteStarted(Description description) throws Exception {
+        synchronized (monitor) {
+            listener.testSuiteStarted(description);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p/>
+     * Synchronized decorator for {@link RunListener#testSuiteFinished(Description)}.
+     * @param description the description of the test suite that just ran.
+     * @throws Exception
+     * @since 4.13
+     */
+    @Override
+    public void testSuiteFinished(Description description) throws Exception {
+        synchronized (monitor) {
+            listener.testSuiteFinished(description);
+        }
+    }
+
+    @Override
+    public void testStarted(Description description) throws Exception {
+        synchronized (monitor) {
+            listener.testStarted(description);
+        }
+    }
+
+    @Override
+    public void testFinished(Description description) throws Exception {
+        synchronized (monitor) {
+            listener.testFinished(description);
+        }
+    }
+
+    @Override
+    public void testFailure(Failure failure) throws Exception {
+        synchronized (monitor) {
+            listener.testFailure(failure);
+        }
+    }
+
+    @Override
+    public void testAssumptionFailure(Failure failure) {
+        synchronized (monitor) {
+            listener.testAssumptionFailure(failure);
+        }
+    }
+
+    @Override
+    public void testIgnored(Description description) throws Exception {
+        synchronized (monitor) {
+            listener.testIgnored(description);
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        return listener.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+        if (!(other instanceof SynchronizedRunListener)) {
+            return false;
+        }
+        SynchronizedRunListener that = (SynchronizedRunListener) other;
+        
+        return listener.equals(that.listener);
+    }
+
+    @Override
+    public String toString() {
+        return listener.toString() + " (with synchronization wrapper)";
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/package-info.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/package-info.java
new file mode 100644
index 0000000..0331c8f
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/notification/package-info.java
@@ -0,0 +1,6 @@
+/**
+ * Provides information about a test run.
+ *
+ * @since 4.0
+ */
+package org.junit.runner.notification;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runner/package-info.java b/google3/third_party/java_src/junit/main/java/org/junit/runner/package-info.java
new file mode 100644
index 0000000..e19fa0b
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runner/package-info.java
@@ -0,0 +1,6 @@
+/**
+ * Provides classes used to describe, collect, run and analyze multiple tests.
+ *
+ * @since 4.0
+ */
+package org.junit.runner;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/AllTests.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/AllTests.java
new file mode 100644
index 0000000..416c99d
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/AllTests.java
@@ -0,0 +1,27 @@
+package org.junit.runners;
+
+import org.junit.internal.runners.SuiteMethod;
+
+/**
+ * Runner for use with JUnit 3.8.x-style AllTests classes
+ * (those that only implement a static <code>suite()</code>
+ * method). For example:
+ * <pre>
+ * &#064;RunWith(AllTests.class)
+ * public class ProductTests {
+ *    public static junit.framework.Test suite() {
+ *       ...
+ *    }
+ * }
+ * </pre>
+ *
+ * @since 4.0
+ */
+public class AllTests extends SuiteMethod {
+    /**
+     * Only called reflectively. Do not use programmatically.
+     */
+    public AllTests(Class<?> klass) throws Throwable {
+        super(klass);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/BlockJUnit4ClassRunner.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/BlockJUnit4ClassRunner.java
new file mode 100644
index 0000000..455341a
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/BlockJUnit4ClassRunner.java
@@ -0,0 +1,473 @@
+package org.junit.runners;
+
+import static org.junit.internal.runners.rules.RuleMemberValidator.RULE_METHOD_VALIDATOR;
+import static org.junit.internal.runners.rules.RuleMemberValidator.RULE_VALIDATOR;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.Test.None;
+import org.junit.internal.runners.model.ReflectiveCallable;
+import org.junit.internal.runners.statements.ExpectException;
+import org.junit.internal.runners.statements.Fail;
+import org.junit.internal.runners.statements.FailOnTimeout;
+import org.junit.internal.runners.statements.InvokeMethod;
+import org.junit.internal.runners.statements.RunAfters;
+import org.junit.internal.runners.statements.RunBefores;
+import org.junit.rules.MethodRule;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.model.FrameworkMember;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.MemberValueConsumer;
+import org.junit.runners.model.MultipleFailureException;
+import org.junit.runners.model.Statement;
+import org.junit.runners.model.TestClass;
+import org.junit.validator.PublicClassValidator;
+import org.junit.validator.TestClassValidator;
+
+/**
+ * Implements the JUnit 4 standard test case class model, as defined by the
+ * annotations in the org.junit package. Many users will never notice this
+ * class: it is now the default test class runner, but it should have exactly
+ * the same behavior as the old test class runner ({@code JUnit4ClassRunner}).
+ * <p>
+ * BlockJUnit4ClassRunner has advantages for writers of custom JUnit runners
+ * that are slight changes to the default behavior, however:
+ *
+ * <ul>
+ * <li>It has a much simpler implementation based on {@link Statement}s,
+ * allowing new operations to be inserted into the appropriate point in the
+ * execution flow.
+ *
+ * <li>It is published, and extension and reuse are encouraged, whereas {@code
+ * JUnit4ClassRunner} was in an internal package, and is now deprecated.
+ * </ul>
+ * <p>
+ * In turn, in 2009 we introduced {@link Rule}s.  In many cases where extending
+ * BlockJUnit4ClassRunner was necessary to add new behavior, {@link Rule}s can
+ * be used, which makes the extension more reusable and composable.
+ *
+ * @since 4.5
+ */
+public class BlockJUnit4ClassRunner extends ParentRunner<FrameworkMethod> {
+    private static TestClassValidator PUBLIC_CLASS_VALIDATOR = new PublicClassValidator();
+
+    private final ConcurrentMap<FrameworkMethod, Description> methodDescriptions = new ConcurrentHashMap<FrameworkMethod, Description>();
+
+    /**
+     * Creates a BlockJUnit4ClassRunner to run {@code testClass}
+     *
+     * @throws InitializationError if the test class is malformed.
+     */
+    public BlockJUnit4ClassRunner(Class<?> testClass) throws InitializationError {
+        super(testClass);
+    }
+
+    /**
+     * Creates a BlockJUnit4ClassRunner to run {@code testClass}.
+     *
+     * @throws InitializationError if the test class is malformed.
+     * @since 4.13
+     */
+    protected BlockJUnit4ClassRunner(TestClass testClass) throws InitializationError {
+        super(testClass);
+    }
+
+    //
+    // Implementation of ParentRunner
+    //
+
+    @Override
+    protected void runChild(final FrameworkMethod method, RunNotifier notifier) {
+        Description description = describeChild(method);
+        if (isIgnored(method)) {
+            notifier.fireTestIgnored(description);
+        } else {
+            Statement statement = new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    methodBlock(method).evaluate();
+                }
+            };
+            runLeaf(statement, description, notifier);
+        }
+    }
+
+    /**
+     * Evaluates whether {@link FrameworkMethod}s are ignored based on the
+     * {@link Ignore} annotation.
+     */
+    @Override
+    protected boolean isIgnored(FrameworkMethod child) {
+        return child.getAnnotation(Ignore.class) != null;
+    }
+
+    @Override
+    protected Description describeChild(FrameworkMethod method) {
+        Description description = methodDescriptions.get(method);
+
+        if (description == null) {
+            description = Description.createTestDescription(getTestClass().getJavaClass(),
+                    testName(method), method.getAnnotations());
+            methodDescriptions.putIfAbsent(method, description);
+        }
+
+        return description;
+    }
+
+    @Override
+    protected List<FrameworkMethod> getChildren() {
+        return computeTestMethods();
+    }
+
+    //
+    // Override in subclasses
+    //
+
+    /**
+     * Returns the methods that run tests. Default implementation returns all
+     * methods annotated with {@code @Test} on this class and superclasses that
+     * are not overridden.
+     */
+    protected List<FrameworkMethod> computeTestMethods() {
+        return getTestClass().getAnnotatedMethods(Test.class);
+    }
+
+    @Override
+    protected void collectInitializationErrors(List<Throwable> errors) {
+        super.collectInitializationErrors(errors);
+
+        validatePublicConstructor(errors);
+        validateNoNonStaticInnerClass(errors);
+        validateConstructor(errors);
+        validateInstanceMethods(errors);
+        validateFields(errors);
+        validateMethods(errors);
+    }
+
+    private void validatePublicConstructor(List<Throwable> errors) {
+        if (getTestClass().getJavaClass() != null) {
+            errors.addAll(PUBLIC_CLASS_VALIDATOR.validateTestClass(getTestClass()));
+        }
+    }
+
+    protected void validateNoNonStaticInnerClass(List<Throwable> errors) {
+        if (getTestClass().isANonStaticInnerClass()) {
+            String gripe = "The inner class " + getTestClass().getName()
+                    + " is not static.";
+            errors.add(new Exception(gripe));
+        }
+    }
+
+    /**
+     * Adds to {@code errors} if the test class has more than one constructor,
+     * or if the constructor takes parameters. Override if a subclass requires
+     * different validation rules.
+     */
+    protected void validateConstructor(List<Throwable> errors) {
+        validateOnlyOneConstructor(errors);
+        validateZeroArgConstructor(errors);
+    }
+
+    /**
+     * Adds to {@code errors} if the test class has more than one constructor
+     * (do not override)
+     */
+    protected void validateOnlyOneConstructor(List<Throwable> errors) {
+        if (!hasOneConstructor()) {
+            String gripe = "Test class should have exactly one public constructor";
+            errors.add(new Exception(gripe));
+        }
+    }
+
+    /**
+     * Adds to {@code errors} if the test class's single constructor takes
+     * parameters (do not override)
+     */
+    protected void validateZeroArgConstructor(List<Throwable> errors) {
+        if (!getTestClass().isANonStaticInnerClass()
+                && hasOneConstructor()
+                && (getTestClass().getOnlyConstructor().getParameterTypes().length != 0)) {
+            String gripe = "Test class should have exactly one public zero-argument constructor";
+            errors.add(new Exception(gripe));
+        }
+    }
+
+    private boolean hasOneConstructor() {
+        return getTestClass().getJavaClass().getConstructors().length == 1;
+    }
+
+    /**
+     * Adds to {@code errors} for each method annotated with {@code @Test},
+     * {@code @Before}, or {@code @After} that is not a public, void instance
+     * method with no arguments.
+     * @deprecated
+     */
+    @Deprecated
+    protected void validateInstanceMethods(List<Throwable> errors) {
+        validatePublicVoidNoArgMethods(After.class, false, errors);
+        validatePublicVoidNoArgMethods(Before.class, false, errors);
+        validateTestMethods(errors);
+
+        if (computeTestMethods().isEmpty()) {
+            errors.add(new Exception("No runnable methods"));
+        }
+    }
+
+    protected void validateFields(List<Throwable> errors) {
+        RULE_VALIDATOR.validate(getTestClass(), errors);
+    }
+
+    private void validateMethods(List<Throwable> errors) {
+        RULE_METHOD_VALIDATOR.validate(getTestClass(), errors);
+    }
+
+    /**
+     * Adds to {@code errors} for each method annotated with {@code @Test}that
+     * is not a public, void instance method with no arguments.
+     */
+    protected void validateTestMethods(List<Throwable> errors) {
+        validatePublicVoidNoArgMethods(Test.class, false, errors);
+    }
+
+    /**
+     * Returns a new fixture for running a test. Default implementation executes
+     * the test class's no-argument constructor (validation should have ensured
+     * one exists).
+     */
+    protected Object createTest() throws Exception {
+        return getTestClass().getOnlyConstructor().newInstance();
+    }
+
+    /**
+     * Returns a new fixture to run a particular test {@code method} against.
+     * Default implementation executes the no-argument {@link #createTest()} method.
+     *
+     * @since 4.13
+     */
+    protected Object createTest(FrameworkMethod method) throws Exception {
+        return createTest();
+    }
+
+    /**
+     * Returns the name that describes {@code method} for {@link Description}s.
+     * Default implementation is the method's name
+     */
+    protected String testName(FrameworkMethod method) {
+        return method.getName();
+    }
+
+    /**
+     * Returns a Statement that, when executed, either returns normally if
+     * {@code method} passes, or throws an exception if {@code method} fails.
+     *
+     * Here is an outline of the default implementation:
+     *
+     * <ul>
+     * <li>Invoke {@code method} on the result of {@link #createTest(org.junit.runners.model.FrameworkMethod)}, and
+     * throw any exceptions thrown by either operation.
+     * <li>HOWEVER, if {@code method}'s {@code @Test} annotation has the {@link Test#expected()}
+     * attribute, return normally only if the previous step threw an
+     * exception of the correct type, and throw an exception otherwise.
+     * <li>HOWEVER, if {@code method}'s {@code @Test} annotation has the {@code
+     * timeout} attribute, throw an exception if the previous step takes more
+     * than the specified number of milliseconds.
+     * <li>ALWAYS run all non-overridden {@code @Before} methods on this class
+     * and superclasses before any of the previous steps; if any throws an
+     * Exception, stop execution and pass the exception on.
+     * <li>ALWAYS run all non-overridden {@code @After} methods on this class
+     * and superclasses after any of the previous steps; all After methods are
+     * always executed: exceptions thrown by previous steps are combined, if
+     * necessary, with exceptions from After methods into a
+     * {@link MultipleFailureException}.
+     * <li>ALWAYS allow {@code @Rule} fields to modify the execution of the
+     * above steps. A {@code Rule} may prevent all execution of the above steps,
+     * or add additional behavior before and after, or modify thrown exceptions.
+     * For more information, see {@link TestRule}
+     * </ul>
+     *
+     * This can be overridden in subclasses, either by overriding this method,
+     * or the implementations creating each sub-statement.
+     */
+    protected Statement methodBlock(final FrameworkMethod method) {
+        Object test;
+        try {
+            test = new ReflectiveCallable() {
+                @Override
+                protected Object runReflectiveCall() throws Throwable {
+                    return createTest(method);
+                }
+            }.run();
+        } catch (Throwable e) {
+            return new Fail(e);
+        }
+
+        Statement statement = methodInvoker(method, test);
+        statement = possiblyExpectingExceptions(method, test, statement);
+        statement = withPotentialTimeout(method, test, statement);
+        statement = withBefores(method, test, statement);
+        statement = withAfters(method, test, statement);
+        statement = withRules(method, test, statement);
+        statement = withInterruptIsolation(statement);
+        return statement;
+    }
+
+    //
+    // Statement builders
+    //
+
+    /**
+     * Returns a {@link Statement} that invokes {@code method} on {@code test}
+     */
+    protected Statement methodInvoker(FrameworkMethod method, Object test) {
+        return new InvokeMethod(method, test);
+    }
+
+    /**
+     * Returns a {@link Statement}: if {@code method}'s {@code @Test} annotation
+     * has the {@link Test#expected()} attribute, return normally only if {@code next}
+     * throws an exception of the correct type, and throw an exception
+     * otherwise.
+     */
+    protected Statement possiblyExpectingExceptions(FrameworkMethod method,
+            Object test, Statement next) {
+        Test annotation = method.getAnnotation(Test.class);
+        Class<? extends Throwable> expectedExceptionClass = getExpectedException(annotation);
+        return expectedExceptionClass != null ? new ExpectException(next, expectedExceptionClass) : next;
+    }
+
+    /**
+     * Returns a {@link Statement}: if {@code method}'s {@code @Test} annotation
+     * has the {@code timeout} attribute, throw an exception if {@code next}
+     * takes more than the specified number of milliseconds.
+     * @deprecated
+     */
+    @Deprecated
+    protected Statement withPotentialTimeout(FrameworkMethod method,
+            Object test, Statement next) {
+        long timeout = getTimeout(method.getAnnotation(Test.class));
+        if (timeout <= 0) {
+            return next;
+        }
+        return FailOnTimeout.builder()
+               .withTimeout(timeout, TimeUnit.MILLISECONDS)
+               .build(next);
+    }
+
+    /**
+     * Returns a {@link Statement}: run all non-overridden {@code @Before}
+     * methods on this class and superclasses before running {@code next}; if
+     * any throws an Exception, stop execution and pass the exception on.
+     */
+    protected Statement withBefores(FrameworkMethod method, Object target,
+            Statement statement) {
+        List<FrameworkMethod> befores = getTestClass().getAnnotatedMethods(
+                Before.class);
+        return befores.isEmpty() ? statement : new RunBefores(statement,
+                befores, target);
+    }
+
+    /**
+     * Returns a {@link Statement}: run all non-overridden {@code @After}
+     * methods on this class and superclasses before running {@code next}; all
+     * After methods are always executed: exceptions thrown by previous steps
+     * are combined, if necessary, with exceptions from After methods into a
+     * {@link MultipleFailureException}.
+     */
+    protected Statement withAfters(FrameworkMethod method, Object target,
+            Statement statement) {
+        List<FrameworkMethod> afters = getTestClass().getAnnotatedMethods(
+                After.class);
+        return afters.isEmpty() ? statement : new RunAfters(statement, afters,
+                target);
+    }
+
+    private Statement withRules(FrameworkMethod method, Object target, Statement statement) {
+        RuleContainer ruleContainer = new RuleContainer();
+        CURRENT_RULE_CONTAINER.set(ruleContainer);
+        try {
+            List<TestRule> testRules = getTestRules(target);
+            for (MethodRule each : rules(target)) {
+                if (!(each instanceof TestRule && testRules.contains(each))) {
+                    ruleContainer.add(each);
+                }
+            }
+            for (TestRule rule : testRules) {
+                ruleContainer.add(rule);
+            }
+        } finally {
+            CURRENT_RULE_CONTAINER.remove();
+        }
+        return ruleContainer.apply(method, describeChild(method), target, statement);
+    }
+
+    /**
+     * @param target the test case instance
+     * @return a list of MethodRules that should be applied when executing this
+     *         test
+     */
+    protected List<MethodRule> rules(Object target) {
+        RuleCollector<MethodRule> collector = new RuleCollector<MethodRule>();
+        getTestClass().collectAnnotatedMethodValues(target, Rule.class, MethodRule.class,
+                collector);
+        getTestClass().collectAnnotatedFieldValues(target, Rule.class, MethodRule.class,
+                collector);
+        return collector.result;
+    }
+
+    /**
+     * @param target the test case instance
+     * @return a list of TestRules that should be applied when executing this
+     *         test
+     */
+    protected List<TestRule> getTestRules(Object target) {
+        RuleCollector<TestRule> collector = new RuleCollector<TestRule>();
+        getTestClass().collectAnnotatedMethodValues(target, Rule.class, TestRule.class, collector);
+        getTestClass().collectAnnotatedFieldValues(target, Rule.class, TestRule.class, collector);
+        return collector.result;
+    }
+
+    private Class<? extends Throwable> getExpectedException(Test annotation) {
+        if (annotation == null || annotation.expected() == None.class) {
+            return null;
+        } else {
+            return annotation.expected();
+        }
+    }
+
+    private long getTimeout(Test annotation) {
+        if (annotation == null) {
+            return 0;
+        }
+        return annotation.timeout();
+    }
+
+    private static final ThreadLocal<RuleContainer> CURRENT_RULE_CONTAINER =
+            new ThreadLocal<RuleContainer>();
+
+    private static class RuleCollector<T> implements MemberValueConsumer<T> {
+        final List<T> result = new ArrayList<T>();
+
+        public void accept(FrameworkMember<?> member, T value) {
+            Rule rule = member.getAnnotation(Rule.class);
+            if (rule != null) {
+                RuleContainer container = CURRENT_RULE_CONTAINER.get();
+                if (container != null) {
+                    container.setOrder(value, rule.order());
+                }
+            }
+            result.add(value);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/JUnit4.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/JUnit4.java
new file mode 100644
index 0000000..28eafb3
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/JUnit4.java
@@ -0,0 +1,25 @@
+package org.junit.runners;
+
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.TestClass;
+
+/**
+ * Aliases the current default JUnit 4 class runner, for future-proofing. If
+ * future versions of JUnit change the default Runner class, they will also
+ * change the definition of this class. Developers wanting to explicitly tag a
+ * class as a JUnit 4 class should use {@code @RunWith(JUnit4.class)}, not,
+ * for example in JUnit 4.5, {@code @RunWith(BlockJUnit4ClassRunner.class)}.
+ * This is the only way this class should be used--any extension that
+ * depends on the implementation details of this class is likely to break
+ * in future versions.
+ *
+ * @since 4.5
+ */
+public final class JUnit4 extends BlockJUnit4ClassRunner {
+    /**
+     * Constructs a new instance of the default runner
+     */
+    public JUnit4(Class<?> klass) throws InitializationError {
+        super(new TestClass(klass));
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/MethodSorters.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/MethodSorters.java
new file mode 100644
index 0000000..5821892
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/MethodSorters.java
@@ -0,0 +1,41 @@
+package org.junit.runners;
+
+import java.lang.reflect.Method;
+import java.util.Comparator;
+
+import org.junit.internal.MethodSorter;
+
+/**
+ * Sort the methods into a specified execution order.
+ * Defines common {@link MethodSorter} implementations.
+ *
+ * @since 4.11
+ */
+public enum MethodSorters {
+    /**
+     * Sorts the test methods by the method name, in lexicographic order,
+     * with {@link Method#toString()} used as a tiebreaker
+     */
+    NAME_ASCENDING(MethodSorter.NAME_ASCENDING),
+
+    /**
+     * Leaves the test methods in the order returned by the JVM.
+     * Note that the order from the JVM may vary from run to run
+     */
+    JVM(null),
+
+    /**
+     * Sorts the test methods in a deterministic, but not predictable, order
+     */
+    DEFAULT(MethodSorter.DEFAULT);
+
+    private final Comparator<Method> comparator;
+
+    private MethodSorters(Comparator<Method> comparator) {
+        this.comparator = comparator;
+    }
+
+    public Comparator<Method> getComparator() {
+        return comparator;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/Parameterized.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/Parameterized.java
new file mode 100644
index 0000000..d11b66a
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/Parameterized.java
@@ -0,0 +1,504 @@
+package org.junit.runners;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+import org.junit.runner.Runner;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InvalidTestClassError;
+import org.junit.runners.model.TestClass;
+import org.junit.runners.parameterized.BlockJUnit4ClassRunnerWithParametersFactory;
+import org.junit.runners.parameterized.ParametersRunnerFactory;
+import org.junit.runners.parameterized.TestWithParameters;
+
+/**
+ * The custom runner <code>Parameterized</code> implements parameterized tests.
+ * When running a parameterized test class, instances are created for the
+ * cross-product of the test methods and the test data elements.
+ * <p>
+ * For example, to test the <code>+</code> operator, write:
+ * <pre>
+ * &#064;RunWith(Parameterized.class)
+ * public class AdditionTest {
+ *     &#064;Parameters(name = &quot;{index}: {0} + {1} = {2}&quot;)
+ *     public static Iterable&lt;Object[]&gt; data() {
+ *         return Arrays.asList(new Object[][] { { 0, 0, 0 }, { 1, 1, 2 },
+ *                 { 3, 2, 5 }, { 4, 3, 7 } });
+ *     }
+ *
+ *     private int firstSummand;
+ *
+ *     private int secondSummand;
+ *
+ *     private int sum;
+ *
+ *     public AdditionTest(int firstSummand, int secondSummand, int sum) {
+ *         this.firstSummand = firstSummand;
+ *         this.secondSummand = secondSummand;
+ *         this.sum = sum;
+ *     }
+ *
+ *     &#064;Test
+ *     public void test() {
+ *         assertEquals(sum, firstSummand + secondSummand);
+ *     }
+ * }
+ * </pre>
+ * <p>
+ * Each instance of <code>AdditionTest</code> will be constructed using the
+ * three-argument constructor and the data values in the
+ * <code>&#064;Parameters</code> method.
+ * <p>
+ * In order that you can easily identify the individual tests, you may provide a
+ * name for the <code>&#064;Parameters</code> annotation. This name is allowed
+ * to contain placeholders, which are replaced at runtime. The placeholders are
+ * <dl>
+ * <dt>{index}</dt>
+ * <dd>the current parameter index</dd>
+ * <dt>{0}</dt>
+ * <dd>the first parameter value</dd>
+ * <dt>{1}</dt>
+ * <dd>the second parameter value</dd>
+ * <dt>...</dt>
+ * <dd>...</dd>
+ * </dl>
+ * <p>
+ * In the example given above, the <code>Parameterized</code> runner creates
+ * names like <code>[2: 3 + 2 = 5]</code>. If you don't use the name parameter,
+ * then the current parameter index is used as name.
+ * <p>
+ * You can also write:
+ * <pre>
+ * &#064;RunWith(Parameterized.class)
+ * public class AdditionTest {
+ *     &#064;Parameters(name = &quot;{index}: {0} + {1} = {2}&quot;)
+ *     public static Iterable&lt;Object[]&gt; data() {
+ *         return Arrays.asList(new Object[][] { { 0, 0, 0 }, { 1, 1, 2 },
+ *                 { 3, 2, 5 }, { 4, 3, 7 } });
+ *     }
+ *
+ *     &#064;Parameter(0)
+ *     public int firstSummand;
+ *
+ *     &#064;Parameter(1)
+ *     public int secondSummand;
+ *
+ *     &#064;Parameter(2)
+ *     public int sum;
+ *
+ *     &#064;Test
+ *     public void test() {
+ *         assertEquals(sum, firstSummand + secondSummand);
+ *     }
+ * }
+ * </pre>
+ * <p>
+ * Each instance of <code>AdditionTest</code> will be constructed with the default constructor
+ * and fields annotated by <code>&#064;Parameter</code>  will be initialized
+ * with the data values in the <code>&#064;Parameters</code> method.
+ *
+ * <p>
+ * The parameters can be provided as an array, too:
+ * 
+ * <pre>
+ * &#064;Parameters
+ * public static Object[][] data() {
+ * 	return new Object[][] { { 0, 0, 0 }, { 1, 1, 2 }, { 3, 2, 5 }, { 4, 3, 7 } } };
+ * }
+ * </pre>
+ * 
+ * <h3>Tests with single parameter</h3>
+ * <p>
+ * If your test needs a single parameter only, you don't have to wrap it with an
+ * array. Instead you can provide an <code>Iterable</code> or an array of
+ * objects.
+ * <pre>
+ * &#064;Parameters
+ * public static Iterable&lt;? extends Object&gt; data() {
+ * 	return Arrays.asList(&quot;first test&quot;, &quot;second test&quot;);
+ * }
+ * </pre>
+ * <p>
+ * or
+ * <pre>
+ * &#064;Parameters
+ * public static Object[] data() {
+ * 	return new Object[] { &quot;first test&quot;, &quot;second test&quot; };
+ * }
+ * </pre>
+ *
+ * <h3>Executing code before/after executing tests for specific parameters</h3>
+ * <p>
+ * If your test needs to perform some preparation or cleanup based on the
+ * parameters, this can be done by adding public static methods annotated with
+ * {@code @BeforeParam}/{@code @AfterParam}. Such methods should either have no
+ * parameters or the same parameters as the test.
+ * <pre>
+ * &#064;BeforeParam
+ * public static void beforeTestsForParameter(String onlyParameter) {
+ *     System.out.println("Testing " + onlyParameter);
+ * }
+ * </pre>
+ *
+ * <h3>Create different runners</h3>
+ * <p>
+ * By default the {@code Parameterized} runner creates a slightly modified
+ * {@link BlockJUnit4ClassRunner} for each set of parameters. You can build an
+ * own {@code Parameterized} runner that creates another runner for each set of
+ * parameters. Therefore you have to build a {@link ParametersRunnerFactory}
+ * that creates a runner for each {@link TestWithParameters}. (
+ * {@code TestWithParameters} are bundling the parameters and the test name.)
+ * The factory must have a public zero-arg constructor.
+ *
+ * <pre>
+ * public class YourRunnerFactory implements ParametersRunnerFactory {
+ *     public Runner createRunnerForTestWithParameters(TestWithParameters test)
+ *             throws InitializationError {
+ *         return YourRunner(test);
+ *     }
+ * }
+ * </pre>
+ * <p>
+ * Use the {@link UseParametersRunnerFactory} to tell the {@code Parameterized}
+ * runner that it should use your factory.
+ *
+ * <pre>
+ * &#064;RunWith(Parameterized.class)
+ * &#064;UseParametersRunnerFactory(YourRunnerFactory.class)
+ * public class YourTest {
+ *     ...
+ * }
+ * </pre>
+ *
+ * <h3>Avoid creating parameters</h3>
+ * <p>With {@link org.junit.Assume assumptions} you can dynamically skip tests.
+ * Assumptions are also supported by the <code>&#064;Parameters</code> method.
+ * Creating parameters is stopped when the assumption fails and none of the
+ * tests in the test class is executed. JUnit reports a
+ * {@link Result#getAssumptionFailureCount() single assumption failure} for the
+ * whole test class in this case.
+ * <pre>
+ * &#064;Parameters
+ * public static Iterable&lt;? extends Object&gt; data() {
+ * 	String os = System.getProperty("os.name").toLowerCase()
+ * 	Assume.assumeTrue(os.contains("win"));
+ * 	return Arrays.asList(&quot;first test&quot;, &quot;second test&quot;);
+ * }
+ * </pre>
+ * @since 4.0
+ */
+public class Parameterized extends Suite {
+    /**
+     * Annotation for a method which provides parameters to be injected into the
+     * test class constructor by <code>Parameterized</code>. The method has to
+     * be public and static.
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    public @interface Parameters {
+        /**
+         * Optional pattern to derive the test's name from the parameters. Use
+         * numbers in braces to refer to the parameters or the additional data
+         * as follows:
+         * <pre>
+         * {index} - the current parameter index
+         * {0} - the first parameter value
+         * {1} - the second parameter value
+         * etc...
+         * </pre>
+         * <p>
+         * Default value is "{index}" for compatibility with previous JUnit
+         * versions.
+         *
+         * @return {@link MessageFormat} pattern string, except the index
+         *         placeholder.
+         * @see MessageFormat
+         */
+        String name() default "{index}";
+    }
+
+    /**
+     * Annotation for fields of the test class which will be initialized by the
+     * method annotated by <code>Parameters</code>.
+     * By using directly this annotation, the test class constructor isn't needed.
+     * Index range must start at 0.
+     * Default value is 0.
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.FIELD)
+    public @interface Parameter {
+        /**
+         * Method that returns the index of the parameter in the array
+         * returned by the method annotated by <code>Parameters</code>.
+         * Index range must start at 0.
+         * Default value is 0.
+         *
+         * @return the index of the parameter.
+         */
+        int value() default 0;
+    }
+
+    /**
+     * Add this annotation to your test class if you want to generate a special
+     * runner. You have to specify a {@link ParametersRunnerFactory} class that
+     * creates such runners. The factory must have a public zero-arg
+     * constructor.
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Inherited
+    @Target(ElementType.TYPE)
+    public @interface UseParametersRunnerFactory {
+        /**
+         * @return a {@link ParametersRunnerFactory} class (must have a default
+         *         constructor)
+         */
+        Class<? extends ParametersRunnerFactory> value() default BlockJUnit4ClassRunnerWithParametersFactory.class;
+    }
+
+    /**
+     * Annotation for {@code public static void} methods which should be executed before
+     * evaluating tests with particular parameters.
+     *
+     * @see org.junit.BeforeClass
+     * @see org.junit.Before
+     * @since 4.13
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    public @interface BeforeParam {
+    }
+
+    /**
+     * Annotation for {@code public static void} methods which should be executed after
+     * evaluating tests with particular parameters.
+     *
+     * @see org.junit.AfterClass
+     * @see org.junit.After
+     * @since 4.13
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    public @interface AfterParam {
+    }
+
+    /**
+     * Only called reflectively. Do not use programmatically.
+     */
+    public Parameterized(Class<?> klass) throws Throwable {
+        this(klass, new RunnersFactory(klass));
+    }
+
+    private Parameterized(Class<?> klass, RunnersFactory runnersFactory) throws Exception {
+        super(klass, runnersFactory.createRunners());
+        validateBeforeParamAndAfterParamMethods(runnersFactory.parameterCount);
+    }
+
+    private void validateBeforeParamAndAfterParamMethods(Integer parameterCount)
+            throws InvalidTestClassError {
+        List<Throwable> errors = new ArrayList<Throwable>();
+        validatePublicStaticVoidMethods(Parameterized.BeforeParam.class, parameterCount, errors);
+        validatePublicStaticVoidMethods(Parameterized.AfterParam.class, parameterCount, errors);
+        if (!errors.isEmpty()) {
+            throw new InvalidTestClassError(getTestClass().getJavaClass(), errors);
+        }
+    }
+
+    private void validatePublicStaticVoidMethods(
+            Class<? extends Annotation> annotation, Integer parameterCount,
+            List<Throwable> errors) {
+        List<FrameworkMethod> methods = getTestClass().getAnnotatedMethods(annotation);
+        for (FrameworkMethod fm : methods) {
+            fm.validatePublicVoid(true, errors);
+            if (parameterCount != null) {
+                int methodParameterCount = fm.getMethod().getParameterTypes().length;
+                if (methodParameterCount != 0 && methodParameterCount != parameterCount) {
+                    errors.add(new Exception("Method " + fm.getName()
+                            + "() should have 0 or " + parameterCount + " parameter(s)"));
+                }
+            }
+        }
+    }
+
+    private static class AssumptionViolationRunner extends Runner {
+        private final Description description;
+        private final AssumptionViolatedException exception;
+
+        AssumptionViolationRunner(TestClass testClass, String methodName,
+                AssumptionViolatedException exception) {
+            this.description = Description
+                    .createTestDescription(testClass.getJavaClass(),
+                            methodName + "() assumption violation");
+            this.exception = exception;
+        }
+
+        @Override
+        public Description getDescription() {
+            return description;
+        }
+
+        @Override
+        public void run(RunNotifier notifier) {
+            notifier.fireTestAssumptionFailed(new Failure(description, exception));
+        }
+    }
+
+    private static class RunnersFactory {
+        private static final ParametersRunnerFactory DEFAULT_FACTORY = new BlockJUnit4ClassRunnerWithParametersFactory();
+
+        private final TestClass testClass;
+        private final FrameworkMethod parametersMethod;
+        private final List<Object> allParameters;
+        private final int parameterCount;
+        private final Runner runnerOverride;
+
+        private RunnersFactory(Class<?> klass) throws Throwable {
+            testClass = new TestClass(klass);
+            parametersMethod = getParametersMethod(testClass);
+            List<Object> allParametersResult;
+            AssumptionViolationRunner assumptionViolationRunner = null;
+            try {
+                allParametersResult = allParameters(testClass, parametersMethod);
+            } catch (AssumptionViolatedException e) {
+                allParametersResult = Collections.emptyList();
+                assumptionViolationRunner = new AssumptionViolationRunner(testClass,
+                        parametersMethod.getName(), e);
+            }
+            allParameters = allParametersResult;
+            runnerOverride = assumptionViolationRunner;
+            parameterCount =
+                    allParameters.isEmpty() ? 0 : normalizeParameters(allParameters.get(0)).length;
+        }
+
+        private List<Runner> createRunners() throws Exception {
+            if (runnerOverride != null) {
+                return Collections.singletonList(runnerOverride);
+            }
+            Parameters parameters = parametersMethod.getAnnotation(Parameters.class);
+            return Collections.unmodifiableList(createRunnersForParameters(
+                    allParameters, parameters.name(),
+                    getParametersRunnerFactory()));
+        }
+
+        private ParametersRunnerFactory getParametersRunnerFactory()
+                throws InstantiationException, IllegalAccessException {
+            UseParametersRunnerFactory annotation = testClass
+                    .getAnnotation(UseParametersRunnerFactory.class);
+            if (annotation == null) {
+                return DEFAULT_FACTORY;
+            } else {
+                Class<? extends ParametersRunnerFactory> factoryClass = annotation
+                        .value();
+                return factoryClass.newInstance();
+            }
+        }
+
+        private TestWithParameters createTestWithNotNormalizedParameters(
+                String pattern, int index, Object parametersOrSingleParameter) {
+            Object[] parameters = normalizeParameters(parametersOrSingleParameter);
+            return createTestWithParameters(testClass, pattern, index, parameters);
+        }
+
+        private static Object[] normalizeParameters(Object parametersOrSingleParameter) {
+            return (parametersOrSingleParameter instanceof Object[]) ? (Object[]) parametersOrSingleParameter
+                    : new Object[] { parametersOrSingleParameter };
+        }
+
+        @SuppressWarnings("unchecked")
+        private static List<Object> allParameters(
+                TestClass testClass, FrameworkMethod parametersMethod) throws Throwable {
+            Object parameters = parametersMethod.invokeExplosively(null);
+            if (parameters instanceof List) {
+                return (List<Object>) parameters;
+            } else if (parameters instanceof Collection) {
+                return new ArrayList<Object>((Collection<Object>) parameters);
+            } else if (parameters instanceof Iterable) {
+                List<Object> result = new ArrayList<Object>();
+                for (Object entry : ((Iterable<Object>) parameters)) {
+                    result.add(entry);
+                }
+                return result;
+            } else if (parameters instanceof Object[]) {
+                return Arrays.asList((Object[]) parameters);
+            } else {
+                throw parametersMethodReturnedWrongType(testClass, parametersMethod);
+            }
+        }
+
+        private static FrameworkMethod getParametersMethod(TestClass testClass) throws Exception {
+            List<FrameworkMethod> methods = testClass
+                    .getAnnotatedMethods(Parameters.class);
+            for (FrameworkMethod each : methods) {
+                if (each.isStatic() && each.isPublic()) {
+                    return each;
+                }
+            }
+
+            throw new Exception("No public static parameters method on class "
+                    + testClass.getName());
+        }
+
+        private List<Runner> createRunnersForParameters(
+                Iterable<Object> allParameters, String namePattern,
+                ParametersRunnerFactory runnerFactory) throws Exception {
+            try {
+                List<TestWithParameters> tests = createTestsForParameters(
+                        allParameters, namePattern);
+                List<Runner> runners = new ArrayList<Runner>();
+                for (TestWithParameters test : tests) {
+                    runners.add(runnerFactory
+                            .createRunnerForTestWithParameters(test));
+                }
+                return runners;
+            } catch (ClassCastException e) {
+                throw parametersMethodReturnedWrongType(testClass, parametersMethod);
+            }
+        }
+
+        private List<TestWithParameters> createTestsForParameters(
+                Iterable<Object> allParameters, String namePattern)
+                throws Exception {
+            int i = 0;
+            List<TestWithParameters> children = new ArrayList<TestWithParameters>();
+            for (Object parametersOfSingleTest : allParameters) {
+                children.add(createTestWithNotNormalizedParameters(namePattern,
+                        i++, parametersOfSingleTest));
+            }
+            return children;
+        }
+
+        private static Exception parametersMethodReturnedWrongType(
+                TestClass testClass, FrameworkMethod parametersMethod) throws Exception {
+            String className = testClass.getName();
+            String methodName = parametersMethod.getName();
+            String message = MessageFormat.format(
+                    "{0}.{1}() must return an Iterable of arrays.", className,
+                    methodName);
+            return new Exception(message);
+        }
+
+        private TestWithParameters createTestWithParameters(
+                TestClass testClass, String pattern, int index,
+                Object[] parameters) {
+            String finalPattern = pattern.replaceAll("\\{index\\}",
+                    Integer.toString(index));
+            String name = MessageFormat.format(finalPattern, parameters);
+            return new TestWithParameters("[" + name + "]", testClass,
+                    Arrays.asList(parameters));
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/ParentRunner.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/ParentRunner.java
new file mode 100644
index 0000000..8b508fd
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/ParentRunner.java
@@ -0,0 +1,589 @@
+package org.junit.runners;
+
+import static org.junit.internal.Checks.notNull;
+import static org.junit.internal.runners.rules.RuleMemberValidator.CLASS_RULE_METHOD_VALIDATOR;
+import static org.junit.internal.runners.rules.RuleMemberValidator.CLASS_RULE_VALIDATOR;
+
+import com.google.j2objc.annotations.AutoreleasePool;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+import org.junit.FixMethodOrder;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.internal.runners.model.EachTestNotifier;
+import org.junit.internal.runners.statements.RunAfters;
+import org.junit.internal.runners.statements.RunBefores;
+import org.junit.rules.RunRules;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.Filterable;
+import org.junit.runner.manipulation.Orderer;
+import org.junit.runner.manipulation.InvalidOrderingException;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runner.manipulation.Orderable;
+import org.junit.runner.manipulation.Sorter;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runner.notification.StoppedByUserException;
+import org.junit.runners.model.FrameworkMember;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.InvalidTestClassError;
+import org.junit.runners.model.MemberValueConsumer;
+import org.junit.runners.model.RunnerScheduler;
+import org.junit.runners.model.Statement;
+import org.junit.runners.model.TestClass;
+import org.junit.validator.AnnotationsValidator;
+import org.junit.validator.TestClassValidator;
+
+/**
+ * Provides most of the functionality specific to a Runner that implements a
+ * "parent node" in the test tree, with children defined by objects of some data
+ * type {@code T}. (For {@link BlockJUnit4ClassRunner}, {@code T} is
+ * {@link Method} . For {@link Suite}, {@code T} is {@link Class}.) Subclasses
+ * must implement finding the children of the node, describing each child, and
+ * running each child. ParentRunner will filter and sort children, handle
+ * {@code @BeforeClass} and {@code @AfterClass} methods,
+ * handle annotated {@link ClassRule}s, create a composite
+ * {@link Description}, and run children sequentially.
+ *
+ * @since 4.5
+ */
+public abstract class ParentRunner<T> extends Runner implements Filterable,
+        Orderable {
+    private static final List<TestClassValidator> VALIDATORS = Collections.<TestClassValidator>singletonList(
+            new AnnotationsValidator());
+
+    private final Lock childrenLock = new ReentrantLock();
+    private final TestClass testClass;
+
+    // Guarded by childrenLock
+    private volatile List<T> filteredChildren = null;
+
+    private volatile RunnerScheduler scheduler = new RunnerScheduler() {
+        public void schedule(Runnable childStatement) {
+            childStatement.run();
+        }
+
+        public void finished() {
+            // do nothing
+        }
+    };
+
+    /**
+     * Constructs a new {@code ParentRunner} that will run {@code @TestClass}
+     */
+    protected ParentRunner(Class<?> testClass) throws InitializationError {
+        this.testClass = createTestClass(testClass);
+        validate();
+    }
+
+   /**
+    * Constructs a new {@code ParentRunner} that will run the {@code TestClass}.
+    *
+    * @since 4.13
+    */
+    protected ParentRunner(TestClass testClass) throws InitializationError {
+       this.testClass = notNull(testClass);
+       validate();
+    }
+
+    /**
+     * @deprecated Please use {@link #ParentRunner(org.junit.runners.model.TestClass)}.
+     * @since 4.12
+     */
+    @Deprecated
+    protected TestClass createTestClass(Class<?> testClass) {
+        return new TestClass(testClass);
+    }
+
+    //
+    // Must be overridden
+    //
+
+    /**
+     * Returns a list of objects that define the children of this Runner.
+     */
+    protected abstract List<T> getChildren();
+
+    /**
+     * Returns a {@link Description} for {@code child}, which can be assumed to
+     * be an element of the list returned by {@link ParentRunner#getChildren()}
+     */
+    protected abstract Description describeChild(T child);
+
+    /**
+     * Runs the test corresponding to {@code child}, which can be assumed to be
+     * an element of the list returned by {@link ParentRunner#getChildren()}.
+     * Subclasses are responsible for making sure that relevant test events are
+     * reported through {@code notifier}
+     */
+    protected abstract void runChild(T child, RunNotifier notifier);
+
+    //
+    // May be overridden
+    //
+
+    /**
+     * Adds to {@code errors} a throwable for each problem noted with the test class (available from {@link #getTestClass()}).
+     * Default implementation adds an error for each method annotated with
+     * {@code @BeforeClass} or {@code @AfterClass} that is not
+     * {@code public static void} with no arguments.
+     */
+    protected void collectInitializationErrors(List<Throwable> errors) {
+        validatePublicVoidNoArgMethods(BeforeClass.class, true, errors);
+        validatePublicVoidNoArgMethods(AfterClass.class, true, errors);
+        validateClassRules(errors);
+        applyValidators(errors);
+    }
+
+    private void applyValidators(List<Throwable> errors) {
+        if (getTestClass().getJavaClass() != null) {
+            for (TestClassValidator each : VALIDATORS) {
+                errors.addAll(each.validateTestClass(getTestClass()));
+            }
+        }
+    }
+
+    /**
+     * Adds to {@code errors} if any method in this class is annotated with
+     * {@code annotation}, but:
+     * <ul>
+     * <li>is not public, or
+     * <li>takes parameters, or
+     * <li>returns something other than void, or
+     * <li>is static (given {@code isStatic is false}), or
+     * <li>is not static (given {@code isStatic is true}).
+     * </ul>
+     */
+    protected void validatePublicVoidNoArgMethods(Class<? extends Annotation> annotation,
+            boolean isStatic, List<Throwable> errors) {
+        List<FrameworkMethod> methods = getTestClass().getAnnotatedMethods(annotation);
+
+        for (FrameworkMethod eachTestMethod : methods) {
+            eachTestMethod.validatePublicVoidNoArg(isStatic, errors);
+        }
+    }
+
+    private void validateClassRules(List<Throwable> errors) {
+        CLASS_RULE_VALIDATOR.validate(getTestClass(), errors);
+        CLASS_RULE_METHOD_VALIDATOR.validate(getTestClass(), errors);
+    }
+
+    /**
+     * Constructs a {@code Statement} to run all of the tests in the test class.
+     * Override to add pre-/post-processing. Here is an outline of the
+     * implementation:
+     * <ol>
+     * <li>Determine the children to be run using {@link #getChildren()}
+     * (subject to any imposed filter and sort).</li>
+     * <li>If there are any children remaining after filtering and ignoring,
+     * construct a statement that will:
+     * <ol>
+     * <li>Apply all {@code ClassRule}s on the test-class and superclasses.</li>
+     * <li>Run all non-overridden {@code @BeforeClass} methods on the test-class
+     * and superclasses; if any throws an Exception, stop execution and pass the
+     * exception on.</li>
+     * <li>Run all remaining tests on the test-class.</li>
+     * <li>Run all non-overridden {@code @AfterClass} methods on the test-class
+     * and superclasses: exceptions thrown by previous steps are combined, if
+     * necessary, with exceptions from AfterClass methods into a
+     * {@link org.junit.runners.model.MultipleFailureException}.</li>
+     * </ol>
+     * </li>
+     * </ol>
+     *
+     * @return {@code Statement}
+     */
+    protected Statement classBlock(final RunNotifier notifier) {
+        Statement statement = childrenInvoker(notifier);
+        if (!areAllChildrenIgnored()) {
+            statement = withBeforeClasses(statement);
+            statement = withAfterClasses(statement);
+            statement = withClassRules(statement);
+            statement = withInterruptIsolation(statement);
+        }
+        return statement;
+    }
+
+    private boolean areAllChildrenIgnored() {
+        for (T child : getFilteredChildren()) {
+            if (!isIgnored(child)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Returns a {@link Statement}: run all non-overridden {@code @BeforeClass} methods on this class
+     * and superclasses before executing {@code statement}; if any throws an
+     * Exception, stop execution and pass the exception on.
+     */
+    protected Statement withBeforeClasses(Statement statement) {
+        List<FrameworkMethod> befores = testClass
+                .getAnnotatedMethods(BeforeClass.class);
+        return befores.isEmpty() ? statement :
+                new RunBefores(statement, befores, null);
+    }
+
+    /**
+     * Returns a {@link Statement}: run all non-overridden {@code @AfterClass} methods on this class
+     * and superclasses after executing {@code statement}; all AfterClass methods are
+     * always executed: exceptions thrown by previous steps are combined, if
+     * necessary, with exceptions from AfterClass methods into a
+     * {@link org.junit.runners.model.MultipleFailureException}.
+     */
+    protected Statement withAfterClasses(Statement statement) {
+        List<FrameworkMethod> afters = testClass
+                .getAnnotatedMethods(AfterClass.class);
+        return afters.isEmpty() ? statement :
+                new RunAfters(statement, afters, null);
+    }
+
+    /**
+     * Returns a {@link Statement}: apply all
+     * static fields assignable to {@link TestRule}
+     * annotated with {@link ClassRule}.
+     *
+     * @param statement the base statement
+     * @return a RunRules statement if any class-level {@link Rule}s are
+     *         found, or the base statement
+     */
+    private Statement withClassRules(Statement statement) {
+        List<TestRule> classRules = classRules();
+        return classRules.isEmpty() ? statement :
+                new RunRules(statement, classRules, getDescription());
+    }
+
+    /**
+     * @return the {@code ClassRule}s that can transform the block that runs
+     *         each method in the tested class.
+     */
+    protected List<TestRule> classRules() {
+        ClassRuleCollector collector = new ClassRuleCollector();
+        testClass.collectAnnotatedMethodValues(null, ClassRule.class, TestRule.class, collector);
+        testClass.collectAnnotatedFieldValues(null, ClassRule.class, TestRule.class, collector);
+        return collector.getOrderedRules();
+    }
+
+    /**
+     * Returns a {@link Statement}: Call {@link #runChild(Object, RunNotifier)}
+     * on each object returned by {@link #getChildren()} (subject to any imposed
+     * filter and sort)
+     */
+    protected Statement childrenInvoker(final RunNotifier notifier) {
+        return new Statement() {
+            @Override
+            public void evaluate() {
+                runChildren(notifier);
+            }
+        };
+    }
+
+    /**
+     * @return a {@link Statement}: clears interrupt status of current thread after execution of statement
+     */
+    protected final Statement withInterruptIsolation(final Statement statement) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                try {
+                    statement.evaluate();
+                } finally {
+                    Thread.interrupted(); // clearing thread interrupted status for isolation
+                }
+            }
+        };
+    }
+
+    /**
+     * Evaluates whether a child is ignored. The default implementation always
+     * returns <code>false</code>.
+     * 
+     * <p>{@link BlockJUnit4ClassRunner}, for example, overrides this method to
+     * filter tests based on the {@link Ignore} annotation.
+     */
+    protected boolean isIgnored(T child) {
+        return false;
+    }
+
+    private void runChildren(final RunNotifier notifier) {
+        final RunnerScheduler currentScheduler = scheduler;
+        try {
+            for (final T each : getFilteredChildren()) {
+                currentScheduler.schedule(new Runnable() {
+                    public void run() {
+                        ParentRunner.this.runChild(each, notifier);
+                    }
+                });
+            }
+        } finally {
+            currentScheduler.finished();
+        }
+    }
+
+    /**
+     * Returns a name used to describe this Runner
+     */
+    protected String getName() {
+        return testClass.getName();
+    }
+
+    //
+    // Available for subclasses
+    //
+
+    /**
+     * Returns a {@link TestClass} object wrapping the class to be executed.
+     */
+    public final TestClass getTestClass() {
+        return testClass;
+    }
+
+    /**
+     * Runs a {@link Statement} that represents a leaf (aka atomic) test.
+     */
+    protected final void runLeaf(Statement statement, Description description,
+            RunNotifier notifier) {
+        EachTestNotifier eachNotifier = new EachTestNotifier(notifier, description);
+        eachNotifier.fireTestStarted();
+        try {
+            statement.evaluate();
+        } catch (AssumptionViolatedException e) {
+            eachNotifier.addFailedAssumption(e);
+        } catch (Throwable e) {
+            eachNotifier.addFailure(e);
+        } finally {
+            eachNotifier.fireTestFinished();
+        }
+    }
+
+    /**
+     * @return the annotations that should be attached to this runner's
+     *         description.
+     */
+    protected Annotation[] getRunnerAnnotations() {
+        return testClass.getAnnotations();
+    }
+
+    //
+    // Implementation of Runner
+    //
+
+    @Override
+    public Description getDescription() {
+        Class<?> clazz = getTestClass().getJavaClass();
+        Description description;
+        // if subclass overrides `getName()` then we should use it
+        // to maintain backwards compatibility with JUnit 4.12
+        if (clazz == null || !clazz.getName().equals(getName())) {
+            description = Description.createSuiteDescription(getName(), getRunnerAnnotations());
+        } else {
+            description = Description.createSuiteDescription(clazz, getRunnerAnnotations());
+        }
+
+        for (T child : getFilteredChildren()) {
+            description.addChild(describeChild(child));
+        }
+        return description;
+    }
+
+    // @AutoreleasePool is a local modification to support translation of this
+    // code to Objective-C using J2ObjC. It causes the translator to add an
+    // autorelease pool around this method which is Objective-C's way of
+    // collecting and cleaning up garbage memory.
+    @AutoreleasePool
+    @Override
+    public void run(final RunNotifier notifier) {
+        EachTestNotifier testNotifier = new EachTestNotifier(notifier,
+                getDescription());
+        testNotifier.fireTestSuiteStarted();
+        try {
+            Statement statement = classBlock(notifier);
+            statement.evaluate();
+        } catch (AssumptionViolatedException e) {
+            testNotifier.addFailedAssumption(e);
+        } catch (StoppedByUserException e) {
+            throw e;
+        } catch (Throwable e) {
+            testNotifier.addFailure(e);
+        } finally {
+            testNotifier.fireTestSuiteFinished();
+        }
+    }
+
+    //
+    // Implementation of Filterable and Sortable
+    //
+
+    public void filter(Filter filter) throws NoTestsRemainException {
+        childrenLock.lock();
+        try {
+            List<T> children = new ArrayList<T>(getFilteredChildren());
+            for (Iterator<T> iter = children.iterator(); iter.hasNext(); ) {
+                T each = iter.next();
+                if (shouldRun(filter, each)) {
+                    try {
+                        filter.apply(each);
+                    } catch (NoTestsRemainException e) {
+                        iter.remove();
+                    }
+                } else {
+                    iter.remove();
+                }
+            }
+            filteredChildren = Collections.unmodifiableList(children);
+            if (filteredChildren.isEmpty()) {
+                throw new NoTestsRemainException();
+            }
+        } finally {
+            childrenLock.unlock();
+        }
+    }
+
+    public void sort(Sorter sorter) {
+        if (shouldNotReorder()) {
+            return;
+        }
+
+        childrenLock.lock();
+        try {
+            for (T each : getFilteredChildren()) {
+                sorter.apply(each);
+            }
+            List<T> sortedChildren = new ArrayList<T>(getFilteredChildren());
+            Collections.sort(sortedChildren, comparator(sorter));
+            filteredChildren = Collections.unmodifiableList(sortedChildren);
+        } finally {
+            childrenLock.unlock();
+        }
+    }
+
+    /**
+     * Implementation of {@link Orderable#order(Orderer)}.
+     *
+     * @since 4.13
+     */
+    public void order(Orderer orderer) throws InvalidOrderingException {
+        if (shouldNotReorder()) {
+            return;
+        }
+
+        childrenLock.lock();
+        try {
+            List<T> children = getFilteredChildren();
+            // In theory, we could have duplicate Descriptions. De-dup them before ordering,
+            // and add them back at the end.
+            Map<Description, List<T>> childMap = new LinkedHashMap<Description, List<T>>(
+                    children.size());
+            for (T child : children) {
+                Description description = describeChild(child);
+                List<T> childrenWithDescription = childMap.get(description);
+                if (childrenWithDescription == null) {
+                    childrenWithDescription = new ArrayList<T>(1);
+                    childMap.put(description, childrenWithDescription);
+                }
+                childrenWithDescription.add(child);
+                orderer.apply(child);
+            }
+
+            List<Description> inOrder = orderer.order(childMap.keySet());
+
+            children = new ArrayList<T>(children.size());
+            for (Description description : inOrder) {
+                children.addAll(childMap.get(description));
+            }
+            filteredChildren = Collections.unmodifiableList(children);
+        } finally {
+            childrenLock.unlock();
+        }
+    }
+
+    //
+    // Private implementation
+    //
+
+    private boolean shouldNotReorder() {
+        // If the test specifies a specific order, do not reorder.
+        return getDescription().getAnnotation(FixMethodOrder.class) != null;
+    }
+
+    private void validate() throws InitializationError {
+        List<Throwable> errors = new ArrayList<Throwable>();
+        collectInitializationErrors(errors);
+        if (!errors.isEmpty()) {
+            throw new InvalidTestClassError(testClass.getJavaClass(), errors);
+        }
+    }
+
+    private List<T> getFilteredChildren() {
+        if (filteredChildren == null) {
+            childrenLock.lock();
+            try {
+                if (filteredChildren == null) {
+                    filteredChildren = Collections.unmodifiableList(
+                            new ArrayList<T>(getChildren()));
+                }
+            } finally {
+                childrenLock.unlock();
+            }
+        }
+        return filteredChildren;
+    }
+
+    private boolean shouldRun(Filter filter, T each) {
+        return filter.shouldRun(describeChild(each));
+    }
+
+    private Comparator<? super T> comparator(final Sorter sorter) {
+        return new Comparator<T>() {
+            public int compare(T o1, T o2) {
+                return sorter.compare(describeChild(o1), describeChild(o2));
+            }
+        };
+    }
+
+    /**
+     * Sets a scheduler that determines the order and parallelization
+     * of children.  Highly experimental feature that may change.
+     */
+    public void setScheduler(RunnerScheduler scheduler) {
+        this.scheduler = scheduler;
+    }
+
+    private static class ClassRuleCollector implements MemberValueConsumer<TestRule> {
+        final List<RuleContainer.RuleEntry> entries = new ArrayList<RuleContainer.RuleEntry>();
+
+        public void accept(FrameworkMember<?> member, TestRule value) {
+            ClassRule rule = member.getAnnotation(ClassRule.class);
+            entries.add(new RuleContainer.RuleEntry(value, RuleContainer.RuleEntry.TYPE_TEST_RULE,
+                    rule != null ? rule.order() : null));
+        }
+
+        public List<TestRule> getOrderedRules() {
+            Collections.sort(entries, RuleContainer.ENTRY_COMPARATOR);
+            List<TestRule> result = new ArrayList<TestRule>(entries.size());
+            for (RuleContainer.RuleEntry entry : entries) {
+                result.add((TestRule) entry.rule);
+            }
+            return result;
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/RuleContainer.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/RuleContainer.java
new file mode 100644
index 0000000..30ddd8d
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/RuleContainer.java
@@ -0,0 +1,113 @@
+package org.junit.runners;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.IdentityHashMap;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.rules.MethodRule;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+/**
+ * Data structure for ordering of {@link TestRule}/{@link MethodRule} instances.
+ *
+ * @since 4.13
+ */
+class RuleContainer {
+    private final IdentityHashMap<Object, Integer> orderValues = new IdentityHashMap<Object, Integer>();
+    private final List<TestRule> testRules = new ArrayList<TestRule>();
+    private final List<MethodRule> methodRules = new ArrayList<MethodRule>();
+
+    /**
+     * Sets order value for the specified rule.
+     */
+    public void setOrder(Object rule, int order) {
+        orderValues.put(rule, order);
+    }
+
+    public void add(MethodRule methodRule) {
+        methodRules.add(methodRule);
+    }
+
+    public void add(TestRule testRule) {
+        testRules.add(testRule);
+    }
+
+    static final Comparator<RuleEntry> ENTRY_COMPARATOR = new Comparator<RuleEntry>() {
+        public int compare(RuleEntry o1, RuleEntry o2) {
+            int result = compareInt(o1.order, o2.order);
+            return result != 0 ? result : o1.type - o2.type;
+        }
+
+        private int compareInt(int a, int b) {
+            return (a < b) ? 1 : (a == b ? 0 : -1);
+        }
+    };
+
+    /**
+     * Returns entries in the order how they should be applied, i.e. inner-to-outer.
+     */
+    private List<RuleEntry> getSortedEntries() {
+        List<RuleEntry> ruleEntries = new ArrayList<RuleEntry>(
+                methodRules.size() + testRules.size());
+        for (MethodRule rule : methodRules) {
+            ruleEntries.add(new RuleEntry(rule, RuleEntry.TYPE_METHOD_RULE, orderValues.get(rule)));
+        }
+        for (TestRule rule : testRules) {
+            ruleEntries.add(new RuleEntry(rule, RuleEntry.TYPE_TEST_RULE, orderValues.get(rule)));
+        }
+        Collections.sort(ruleEntries, ENTRY_COMPARATOR);
+        return ruleEntries;
+    }
+
+    /**
+     * Applies all the rules ordered accordingly to the specified {@code statement}.
+     */
+    public Statement apply(FrameworkMethod method, Description description, Object target,
+            Statement statement) {
+        if (methodRules.isEmpty() && testRules.isEmpty()) {
+            return statement;
+        }
+        Statement result = statement;
+        for (RuleEntry ruleEntry : getSortedEntries()) {
+            if (ruleEntry.type == RuleEntry.TYPE_TEST_RULE) {
+                result = ((TestRule) ruleEntry.rule).apply(result, description);
+            } else {
+                result = ((MethodRule) ruleEntry.rule).apply(result, method, target);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Returns rule instances in the order how they should be applied, i.e. inner-to-outer.
+     * VisibleForTesting
+     */
+    List<Object> getSortedRules() {
+        List<Object> result = new ArrayList<Object>();
+        for (RuleEntry entry : getSortedEntries()) {
+            result.add(entry.rule);
+        }
+        return result;
+    }
+
+    static class RuleEntry {
+        static final int TYPE_TEST_RULE = 1;
+        static final int TYPE_METHOD_RULE = 0;
+
+        final Object rule;
+        final int type;
+        final int order;
+
+        RuleEntry(Object rule, int type, Integer order) {
+            this.rule = rule;
+            this.type = type;
+            this.order = order != null ? order.intValue() : Rule.DEFAULT_ORDER;
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/Suite.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/Suite.java
new file mode 100644
index 0000000..c2c8e58
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/Suite.java
@@ -0,0 +1,130 @@
+package org.junit.runners;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.internal.builders.AllDefaultPossibilitiesBuilder;
+import org.junit.runner.Description;
+import org.junit.runner.Runner;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.RunnerBuilder;
+
+/**
+ * Using <code>Suite</code> as a runner allows you to manually
+ * build a suite containing tests from many classes. It is the JUnit 4 equivalent of the JUnit 3.8.x
+ * static {@link junit.framework.Test} <code>suite()</code> method. To use it, annotate a class
+ * with <code>@RunWith(Suite.class)</code> and <code>@SuiteClasses({TestClass1.class, ...})</code>.
+ * When you run this class, it will run all the tests in all the suite classes.
+ *
+ * @since 4.0
+ */
+public class Suite extends ParentRunner<Runner> {
+    /**
+     * Returns an empty suite.
+     */
+    public static Runner emptySuite() {
+        try {
+            return new Suite((Class<?>) null, new Class<?>[0]);
+        } catch (InitializationError e) {
+            throw new RuntimeException("This shouldn't be possible");
+        }
+    }
+
+    /**
+     * The <code>SuiteClasses</code> annotation specifies the classes to be run when a class
+     * annotated with <code>@RunWith(Suite.class)</code> is run.
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.TYPE)
+    @Inherited
+    public @interface SuiteClasses {
+        /**
+         * @return the classes to be run
+         */
+        Class<?>[] value();
+    }
+
+    private static Class<?>[] getAnnotatedClasses(Class<?> klass) throws InitializationError {
+        SuiteClasses annotation = klass.getAnnotation(SuiteClasses.class);
+        if (annotation == null) {
+            throw new InitializationError(String.format("class '%s' must have a SuiteClasses annotation", klass.getName()));
+        }
+        return annotation.value();
+    }
+
+    private final List<Runner> runners;
+
+    /**
+     * Called reflectively on classes annotated with <code>@RunWith(Suite.class)</code>
+     *
+     * @param klass the root class
+     * @param builder builds runners for classes in the suite
+     */
+    public Suite(Class<?> klass, RunnerBuilder builder) throws InitializationError {
+        this(builder, klass, getAnnotatedClasses(klass));
+    }
+
+    /**
+     * Call this when there is no single root class (for example, multiple class names
+     * passed on the command line to {@link org.junit.runner.JUnitCore}
+     *
+     * @param builder builds runners for classes in the suite
+     * @param classes the classes in the suite
+     */
+    public Suite(RunnerBuilder builder, Class<?>[] classes) throws InitializationError {
+        this(null, builder.runners(null, classes));
+    }
+
+    /**
+     * Call this when the default builder is good enough. Left in for compatibility with JUnit 4.4.
+     *
+     * @param klass the root of the suite
+     * @param suiteClasses the classes in the suite
+     */
+    protected Suite(Class<?> klass, Class<?>[] suiteClasses) throws InitializationError {
+        this(new AllDefaultPossibilitiesBuilder(), klass, suiteClasses);
+    }
+
+    /**
+     * Called by this class and subclasses once the classes making up the suite have been determined
+     *
+     * @param builder builds runners for classes in the suite
+     * @param klass the root of the suite
+     * @param suiteClasses the classes in the suite
+     */
+    protected Suite(RunnerBuilder builder, Class<?> klass, Class<?>[] suiteClasses) throws InitializationError {
+        this(klass, builder.runners(klass, suiteClasses));
+    }
+
+    /**
+     * Called by this class and subclasses once the runners making up the suite have been determined
+     *
+     * @param klass root of the suite
+     * @param runners for each class in the suite, a {@link Runner}
+     */
+    protected Suite(Class<?> klass, List<Runner> runners) throws InitializationError {
+        super(klass);
+        this.runners = Collections.unmodifiableList(runners);
+    }
+
+    @Override
+    protected List<Runner> getChildren() {
+        return runners;
+    }
+
+    @Override
+    protected Description describeChild(Runner child) {
+        return child.getDescription();
+    }
+
+    @Override
+    protected void runChild(Runner runner, final RunNotifier notifier) {
+        runner.run(notifier);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/Annotatable.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/Annotatable.java
new file mode 100644
index 0000000..8eff6fd
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/Annotatable.java
@@ -0,0 +1,20 @@
+package org.junit.runners.model;
+
+import java.lang.annotation.Annotation;
+
+/**
+ * A model element that may have annotations.
+ * 
+ * @since 4.12
+ */
+public interface Annotatable {
+    /**
+     * Returns the model elements' annotations.
+     */
+    Annotation[] getAnnotations();
+
+    /**
+     * Returns the annotation on the model element of the given type, or @code{null}
+     */
+    <T extends Annotation> T getAnnotation(Class<T> annotationType);
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/FrameworkField.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/FrameworkField.java
new file mode 100644
index 0000000..ea2b16f
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/FrameworkField.java
@@ -0,0 +1,99 @@
+package org.junit.runners.model;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+
+import org.junit.runners.BlockJUnit4ClassRunner;
+
+/**
+ * Represents a field on a test class (currently used only for Rules in
+ * {@link BlockJUnit4ClassRunner}, but custom runners can make other uses)
+ *
+ * @since 4.7
+ */
+public class FrameworkField extends FrameworkMember<FrameworkField> {
+    private final Field field;
+
+    /**
+     * Returns a new {@code FrameworkField} for {@code field}.
+     *
+     * <p>Access relaxed to {@code public} since version 4.13.1.
+     */
+    public FrameworkField(Field field) {
+        if (field == null) {
+            throw new NullPointerException(
+                    "FrameworkField cannot be created without an underlying field.");
+        }
+        this.field = field;
+
+        if (isPublic()) {
+            // This field could be a public field in a package-scope base class
+            try {
+                field.setAccessible(true);
+            } catch (SecurityException e) {
+                // We may get an IllegalAccessException when we try to access the field
+            }
+        }
+    }
+
+    @Override
+    public String getName() {
+        return getField().getName();
+    }
+
+    public Annotation[] getAnnotations() {
+        return field.getAnnotations();
+    }
+
+    public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
+        return field.getAnnotation(annotationType);
+    }
+
+    @Override
+    public boolean isShadowedBy(FrameworkField otherMember) {
+        return otherMember.getName().equals(getName());
+    }
+
+    @Override
+    boolean isBridgeMethod() {
+        return false;
+    }
+
+    @Override
+    protected int getModifiers() {
+        return field.getModifiers();
+    }
+
+    /**
+     * @return the underlying java Field
+     */
+    public Field getField() {
+        return field;
+    }
+
+    /**
+     * @return the underlying Java Field type
+     * @see java.lang.reflect.Field#getType()
+     */
+    @Override
+    public Class<?> getType() {
+        return field.getType();
+    }
+    
+    @Override
+    public Class<?> getDeclaringClass() {
+        return field.getDeclaringClass();
+    }
+
+    /**
+     * Attempts to retrieve the value of this field on {@code target}
+     */
+    public Object get(Object target) throws IllegalArgumentException, IllegalAccessException {
+        return field.get(target);
+    }
+
+    @Override
+    public String toString() {
+        return field.toString();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/FrameworkMember.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/FrameworkMember.java
new file mode 100644
index 0000000..5634b3f
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/FrameworkMember.java
@@ -0,0 +1,59 @@
+package org.junit.runners.model;
+
+import java.lang.reflect.Modifier;
+import java.util.List;
+
+/**
+ * Parent class for {@link FrameworkField} and {@link FrameworkMethod}
+ *
+ * @since 4.7
+ */
+public abstract class FrameworkMember<T extends FrameworkMember<T>> implements
+        Annotatable {
+    abstract boolean isShadowedBy(T otherMember);
+
+    T handlePossibleBridgeMethod(List<T> members) {
+        for (int i = members.size() - 1; i >=0; i--) {
+            T otherMember = members.get(i);
+            if (isShadowedBy(otherMember)) {
+                if (otherMember.isBridgeMethod()) {
+                    /*
+                     *  We need to return the previously-encountered bridge method
+                     *  because JUnit won't be able to call the parent method,
+                     *  because the parent class isn't public.
+                     */
+                    members.remove(i);
+                    return otherMember;
+                }
+                // We found a shadowed member that isn't a bridge method. Ignore it.
+                return null;
+            }
+        }
+        // No shadow or bridge method found. The caller should add *this* member.
+        return (T) this;
+    }
+
+    abstract boolean isBridgeMethod();
+
+    protected abstract int getModifiers();
+
+    /**
+     * Returns true if this member is static, false if not.
+     */
+    public boolean isStatic() {
+        return Modifier.isStatic(getModifiers());
+    }
+
+    /**
+     * Returns true if this member is public, false if not.
+     */
+    public boolean isPublic() {
+        return Modifier.isPublic(getModifiers());
+    }
+
+    public abstract String getName();
+
+    public abstract Class<?> getType();
+
+    public abstract Class<?> getDeclaringClass();
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/FrameworkMethod.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/FrameworkMethod.java
new file mode 100644
index 0000000..4471407
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/FrameworkMethod.java
@@ -0,0 +1,216 @@
+package org.junit.runners.model;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.List;
+
+import org.junit.internal.runners.model.ReflectiveCallable;
+
+/**
+ * Represents a method on a test class to be invoked at the appropriate point in
+ * test execution. These methods are usually marked with an annotation (such as
+ * {@code @Test}, {@code @Before}, {@code @After}, {@code @BeforeClass},
+ * {@code @AfterClass}, etc.)
+ *
+ * @since 4.5
+ */
+public class FrameworkMethod extends FrameworkMember<FrameworkMethod> {
+    private final Method method;
+
+    /**
+     * Returns a new {@code FrameworkMethod} for {@code method}
+     */
+    public FrameworkMethod(Method method) {
+        if (method == null) {
+            throw new NullPointerException(
+                    "FrameworkMethod cannot be created without an underlying method.");
+        }
+        this.method = method;
+
+        if (isPublic()) {
+            // This method could be a public method in a package-scope base class
+            try {
+                method.setAccessible(true);
+            } catch (SecurityException  e) {
+                // We may get an IllegalAccessException when we try to call the method
+            }
+        }
+    }
+
+    /**
+     * Returns the underlying Java method
+     */
+    public Method getMethod() {
+        return method;
+    }
+
+    /**
+     * Returns the result of invoking this method on {@code target} with
+     * parameters {@code params}. {@link InvocationTargetException}s thrown are
+     * unwrapped, and their causes rethrown.
+     */
+    public Object invokeExplosively(final Object target, final Object... params)
+            throws Throwable {
+        return new ReflectiveCallable() {
+            @Override
+            protected Object runReflectiveCall() throws Throwable {
+                return method.invoke(target, params);
+            }
+        }.run();
+    }
+
+    /**
+     * Returns the method's name
+     */
+    @Override
+    public String getName() {
+        return method.getName();
+    }
+
+    /**
+     * Adds to {@code errors} if this method:
+     * <ul>
+     * <li>is not public, or
+     * <li>takes parameters, or
+     * <li>returns something other than void, or
+     * <li>is static (given {@code isStatic is false}), or
+     * <li>is not static (given {@code isStatic is true}).
+     * </ul>
+     */
+    public void validatePublicVoidNoArg(boolean isStatic, List<Throwable> errors) {
+        validatePublicVoid(isStatic, errors);
+        if (method.getParameterTypes().length != 0) {
+            errors.add(new Exception("Method " + method.getName() + " should have no parameters"));
+        }
+    }
+
+
+    /**
+     * Adds to {@code errors} if this method:
+     * <ul>
+     * <li>is not public, or
+     * <li>returns something other than void, or
+     * <li>is static (given {@code isStatic is false}), or
+     * <li>is not static (given {@code isStatic is true}).
+     * </ul>
+     */
+    public void validatePublicVoid(boolean isStatic, List<Throwable> errors) {
+        if (isStatic() != isStatic) {
+            String state = isStatic ? "should" : "should not";
+            errors.add(new Exception("Method " + method.getName() + "() " + state + " be static"));
+        }
+        if (!isPublic()) {
+            errors.add(new Exception("Method " + method.getName() + "() should be public"));
+        }
+        if (method.getReturnType() != Void.TYPE) {
+            errors.add(new Exception("Method " + method.getName() + "() should be void"));
+        }
+    }
+
+    @Override
+    protected int getModifiers() {
+        return method.getModifiers();
+    }
+
+    /**
+     * Returns the return type of the method
+     */
+    public Class<?> getReturnType() {
+        return method.getReturnType();
+    }
+
+    /**
+     * Returns the return type of the method
+     */
+    @Override
+    public Class<?> getType() {
+        return getReturnType();
+    }
+
+    /**
+     * Returns the class where the method is actually declared
+     */
+    @Override
+    public Class<?> getDeclaringClass() {
+        return method.getDeclaringClass();
+    }
+
+    public void validateNoTypeParametersOnArgs(List<Throwable> errors) {
+        new NoGenericTypeParametersValidator(method).validate(errors);
+    }
+
+    @Override
+    public boolean isShadowedBy(FrameworkMethod other) {
+        if (!other.getName().equals(getName())) {
+            return false;
+        }
+        if (other.getParameterTypes().length != getParameterTypes().length) {
+            return false;
+        }
+        for (int i = 0; i < other.getParameterTypes().length; i++) {
+            if (!other.getParameterTypes()[i].equals(getParameterTypes()[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    boolean isBridgeMethod() {
+        return method.isBridge();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!FrameworkMethod.class.isInstance(obj)) {
+            return false;
+        }
+        return ((FrameworkMethod) obj).method.equals(method);
+    }
+
+    @Override
+    public int hashCode() {
+        return method.hashCode();
+    }
+
+    /**
+     * Returns true if this is a no-arg method that returns a value assignable
+     * to {@code type}
+     *
+     * @deprecated This is used only by the Theories runner, and does not
+     *             use all the generic type info that it ought to. It will be replaced
+     *             with a forthcoming ParameterSignature#canAcceptResultOf(FrameworkMethod)
+     *             once Theories moves to junit-contrib.
+     */
+    @Deprecated
+    public boolean producesType(Type type) {
+        return getParameterTypes().length == 0 && type instanceof Class<?>
+                && ((Class<?>) type).isAssignableFrom(method.getReturnType());
+    }
+
+    private Class<?>[] getParameterTypes() {
+        return method.getParameterTypes();
+    }
+
+    /**
+     * Returns the annotations on this method
+     */
+    public Annotation[] getAnnotations() {
+        return method.getAnnotations();
+    }
+
+    /**
+     * Returns the annotation of type {@code annotationType} on this method, if
+     * one exists.
+     */
+    public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
+        return method.getAnnotation(annotationType);
+    }
+
+    @Override
+    public String toString() {
+        return method.toString();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/InitializationError.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/InitializationError.java
new file mode 100644
index 0000000..dd9c8b3
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/InitializationError.java
@@ -0,0 +1,47 @@
+package org.junit.runners.model;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Represents one or more problems encountered while initializing a Runner
+ *
+ * @since 4.5
+ */
+public class InitializationError extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit4/issues/976
+     */
+    private final List<Throwable> fErrors;
+
+    /**
+     * Construct a new {@code InitializationError} with one or more
+     * errors {@code errors} as causes
+     */
+    public InitializationError(List<Throwable> errors) {
+        this.fErrors = errors;
+    }
+
+    public InitializationError(Throwable error) {
+        this(Arrays.asList(error));
+    }
+
+    /**
+     * Construct a new {@code InitializationError} with one cause
+     * with message {@code string}
+     */
+    public InitializationError(String string) {
+        this(new Exception(string));
+    }
+
+    /**
+     * Returns one or more Throwables that led to this initialization error.
+     */
+    public List<Throwable> getCauses() {
+        return fErrors;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/InvalidTestClassError.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/InvalidTestClassError.java
new file mode 100644
index 0000000..57be610
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/InvalidTestClassError.java
@@ -0,0 +1,39 @@
+package org.junit.runners.model;
+
+import java.util.List;
+
+/**
+ * Thrown by {@link org.junit.runner.Runner}s in case the class under test is not valid.
+ * <p>
+ * Its message conveniently lists all of the validation errors.
+ *
+ * @since 4.13
+ */
+public class InvalidTestClassError extends InitializationError {
+    private static final long serialVersionUID = 1L;
+
+    private final String message;
+
+    public InvalidTestClassError(Class<?> offendingTestClass, List<Throwable> validationErrors) {
+        super(validationErrors);
+        this.message = createMessage(offendingTestClass, validationErrors);
+    }
+
+    private static String createMessage(Class<?> testClass, List<Throwable> validationErrors) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(String.format("Invalid test class '%s':", testClass.getName()));
+        int i = 1;
+        for (Throwable error : validationErrors) {
+            sb.append("\n  " + (i++) + ". " + error.getMessage());
+        }
+        return sb.toString();
+    }
+
+    /**
+     * @return a message with a list of all of the validation errors
+     */
+    @Override
+    public String getMessage() {
+        return message;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/MemberValueConsumer.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/MemberValueConsumer.java
new file mode 100644
index 0000000..a6157bf
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/MemberValueConsumer.java
@@ -0,0 +1,18 @@
+package org.junit.runners.model;
+
+/**
+ * Represents a receiver for values of annotated fields/methods together with the declaring member.
+ *
+ * @see TestClass#collectAnnotatedFieldValues(Object, Class, Class, MemberValueConsumer)
+ * @see TestClass#collectAnnotatedMethodValues(Object, Class, Class, MemberValueConsumer)
+ * @since 4.13
+ */
+public interface MemberValueConsumer<T> {
+    /**
+     * Receives the next value and its declaring member.
+     *
+     * @param member declaring member ({@link FrameworkMethod} or {@link FrameworkField})
+     * @param value the value of the next member
+     */
+    void accept(FrameworkMember<?> member, T value);
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/MultipleFailureException.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/MultipleFailureException.java
new file mode 100644
index 0000000..8e355a7
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/MultipleFailureException.java
@@ -0,0 +1,104 @@
+package org.junit.runners.model;
+
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.TestCouldNotBeSkippedException;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.internal.Throwables;
+
+/**
+ * Collects multiple {@code Throwable}s into one exception.
+ *
+ * @since 4.9
+ */
+public class MultipleFailureException extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit4/issues/976
+     */
+    private final List<Throwable> fErrors;
+
+    public MultipleFailureException(List<Throwable> errors) {
+        if (errors.isEmpty()) {
+            throw new IllegalArgumentException(
+                    "List of Throwables must not be empty");
+        }
+        this.fErrors = new ArrayList<Throwable>(errors.size());
+        for (Throwable error : errors) {
+            if (error instanceof AssumptionViolatedException) {
+                error = new TestCouldNotBeSkippedException((AssumptionViolatedException) error);
+            }
+            fErrors.add(error);
+        }
+    }
+
+    public List<Throwable> getFailures() {
+        return Collections.unmodifiableList(fErrors);
+    }
+
+    @Override
+    public String getMessage() {
+        StringBuilder sb = new StringBuilder(
+                String.format("There were %d errors:", fErrors.size()));
+        for (Throwable e : fErrors) {
+            sb.append(String.format("%n  %s(%s)", e.getClass().getName(), e.getMessage()));
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public void printStackTrace() {
+        for (Throwable e: fErrors) {
+            e.printStackTrace();
+        }
+    }
+    
+    @Override
+    public void printStackTrace(PrintStream s) {
+        for (Throwable e: fErrors) {
+            e.printStackTrace(s);
+        }
+    }
+    
+    @Override
+    public void printStackTrace(PrintWriter s) {
+        for (Throwable e: fErrors) {
+            e.printStackTrace(s);
+        }
+    }
+    
+    /**
+     * Asserts that a list of throwables is empty. If it isn't empty,
+     * will throw {@link MultipleFailureException} (if there are
+     * multiple throwables in the list) or the first element in the list
+     * (if there is only one element).
+     *
+     * @param errors list to check
+     * @throws Exception or Error if the list is not empty
+     */
+    @SuppressWarnings("deprecation")
+    public static void assertEmpty(List<Throwable> errors) throws Exception {
+        if (errors.isEmpty()) {
+            return;
+        }
+        if (errors.size() == 1) {
+            throw Throwables.rethrowAsException(errors.get(0));
+        }
+
+        /*
+           * Many places in the code are documented to throw
+           * org.junit.internal.runners.model.MultipleFailureException.
+           * That class now extends this one, so we throw the internal
+           * exception in case developers have tests that catch
+           * MultipleFailureException.
+           */
+        throw new org.junit.internal.runners.model.MultipleFailureException(errors);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/NoGenericTypeParametersValidator.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/NoGenericTypeParametersValidator.java
new file mode 100644
index 0000000..386b7ff
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/NoGenericTypeParametersValidator.java
@@ -0,0 +1,58 @@
+package org.junit.runners.model;
+
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.List;
+
+class NoGenericTypeParametersValidator {
+    private final Method method;
+
+    NoGenericTypeParametersValidator(Method method) {
+        this.method = method;
+    }
+
+    void validate(List<Throwable> errors) {
+        for (Type each : method.getGenericParameterTypes()) {
+            validateNoTypeParameterOnType(each, errors);
+        }
+    }
+
+    private void validateNoTypeParameterOnType(Type type, List<Throwable> errors) {
+        if (type instanceof TypeVariable<?>) {
+            errors.add(new Exception("Method " + method.getName()
+                    + "() contains unresolved type variable " + type));
+        } else if (type instanceof ParameterizedType) {
+            validateNoTypeParameterOnParameterizedType((ParameterizedType) type, errors);
+        } else if (type instanceof WildcardType) {
+            validateNoTypeParameterOnWildcardType((WildcardType) type, errors);
+        } else if (type instanceof GenericArrayType) {
+            validateNoTypeParameterOnGenericArrayType((GenericArrayType) type, errors);
+        }
+    }
+
+    private void validateNoTypeParameterOnParameterizedType(ParameterizedType parameterized,
+            List<Throwable> errors) {
+        for (Type each : parameterized.getActualTypeArguments()) {
+            validateNoTypeParameterOnType(each, errors);
+        }
+    }
+
+    private void validateNoTypeParameterOnWildcardType(WildcardType wildcard,
+            List<Throwable> errors) {
+        for (Type each : wildcard.getUpperBounds()) {
+            validateNoTypeParameterOnType(each, errors);
+        }
+        for (Type each : wildcard.getLowerBounds()) {
+            validateNoTypeParameterOnType(each, errors);
+        }
+    }
+
+    private void validateNoTypeParameterOnGenericArrayType(
+            GenericArrayType arrayType, List<Throwable> errors) {
+        validateNoTypeParameterOnType(arrayType.getGenericComponentType(), errors);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/RunnerBuilder.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/RunnerBuilder.java
new file mode 100644
index 0000000..ba7c9e2
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/RunnerBuilder.java
@@ -0,0 +1,132 @@
+package org.junit.runners.model;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.internal.runners.ErrorReportingRunner;
+import org.junit.runner.Description;
+import org.junit.runner.OrderWith;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.InvalidOrderingException;
+import org.junit.runner.manipulation.Ordering;
+
+/**
+ * A RunnerBuilder is a strategy for constructing runners for classes.
+ *
+ * Only writers of custom runners should use <code>RunnerBuilder</code>s.  A custom runner class with a constructor taking
+ * a <code>RunnerBuilder</code> parameter will be passed the instance of <code>RunnerBuilder</code> used to build that runner itself.
+ * For example,
+ * imagine a custom runner that builds suites based on a list of classes in a text file:
+ *
+ * <pre>
+ * \@RunWith(TextFileSuite.class)
+ * \@SuiteSpecFile("mysuite.txt")
+ * class MySuite {}
+ * </pre>
+ *
+ * The implementation of TextFileSuite might include:
+ *
+ * <pre>
+ * public TextFileSuite(Class testClass, RunnerBuilder builder) {
+ *   // ...
+ *   for (String className : readClassNames())
+ *     addRunner(builder.runnerForClass(Class.forName(className)));
+ *   // ...
+ * }
+ * </pre>
+ *
+ * @see org.junit.runners.Suite
+ * @since 4.5
+ */
+public abstract class RunnerBuilder {
+    private final Set<Class<?>> parents = new HashSet<Class<?>>();
+
+    /**
+     * Override to calculate the correct runner for a test class at runtime.
+     *
+     * @param testClass class to be run
+     * @return a Runner
+     * @throws Throwable if a runner cannot be constructed
+     */
+    public abstract Runner runnerForClass(Class<?> testClass) throws Throwable;
+
+    /**
+     * Always returns a runner for the given test class.
+     *
+     * <p>In case of an exception a runner will be returned that prints an error instead of running
+     * tests.
+     *
+     * <p>Note that some of the internal JUnit implementations of RunnerBuilder will return
+     * {@code null} from this method, but no RunnerBuilder passed to a Runner constructor will
+     * return {@code null} from this method.
+     *
+     * @param testClass class to be run
+     * @return a Runner
+     */
+    public Runner safeRunnerForClass(Class<?> testClass) {
+        try {
+            Runner runner = runnerForClass(testClass);
+            if (runner != null) {
+                configureRunner(runner);
+            }
+            return runner;
+        } catch (Throwable e) {
+            return new ErrorReportingRunner(testClass, e);
+        }
+    }
+
+    private void configureRunner(Runner runner) throws InvalidOrderingException {
+        Description description = runner.getDescription();
+        OrderWith orderWith = description.getAnnotation(OrderWith.class);
+        if (orderWith != null) {
+            Ordering ordering = Ordering.definedBy(orderWith.value(), description);
+            ordering.apply(runner);
+        }
+    }
+
+    Class<?> addParent(Class<?> parent) throws InitializationError {
+        if (!parents.add(parent)) {
+            throw new InitializationError(String.format("class '%s' (possibly indirectly) contains itself as a SuiteClass", parent.getName()));
+        }
+        return parent;
+    }
+
+    void removeParent(Class<?> klass) {
+        parents.remove(klass);
+    }
+
+    /**
+     * Constructs and returns a list of Runners, one for each child class in
+     * {@code children}.  Care is taken to avoid infinite recursion:
+     * this builder will throw an exception if it is requested for another
+     * runner for {@code parent} before this call completes.
+     */
+    public List<Runner> runners(Class<?> parent, Class<?>[] children)
+            throws InitializationError {
+        addParent(parent);
+
+        try {
+            return runners(children);
+        } finally {
+            removeParent(parent);
+        }
+    }
+
+    public List<Runner> runners(Class<?> parent, List<Class<?>> children)
+            throws InitializationError {
+        return runners(parent, children.toArray(new Class<?>[0]));
+    }
+
+    private List<Runner> runners(Class<?>[] children) {
+        List<Runner> runners = new ArrayList<Runner>();
+        for (Class<?> each : children) {
+            Runner childRunner = safeRunnerForClass(each);
+            if (childRunner != null) {
+                runners.add(childRunner);
+            }
+        }
+        return runners;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/RunnerScheduler.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/RunnerScheduler.java
new file mode 100644
index 0000000..db43308
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/RunnerScheduler.java
@@ -0,0 +1,23 @@
+package org.junit.runners.model;
+
+/**
+ * Represents a strategy for scheduling when individual test methods
+ * should be run (in serial or parallel)
+ *
+ * WARNING: still experimental, may go away.
+ *
+ * @since 4.7
+ */
+public interface RunnerScheduler {
+    /**
+     * Schedule a child statement to run
+     */
+    void schedule(Runnable childStatement);
+
+    /**
+     * Override to implement any behavior that must occur
+     * after all children have been scheduled (for example,
+     * waiting for them all to finish)
+     */
+    void finished();
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/Statement.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/Statement.java
new file mode 100644
index 0000000..fa53fa1
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/Statement.java
@@ -0,0 +1,15 @@
+package org.junit.runners.model;
+
+
+/**
+ * Represents one or more actions to be taken at runtime in the course
+ * of running a JUnit test suite.
+ *
+ * @since 4.5
+ */
+public abstract class Statement {
+    /**
+     * Run the action, throwing a {@code Throwable} if anything goes wrong.
+     */
+    public abstract void evaluate() throws Throwable;
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/TestClass.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/TestClass.java
new file mode 100644
index 0000000..3032d52
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/TestClass.java
@@ -0,0 +1,348 @@
+package org.junit.runners.model;
+
+import static java.lang.reflect.Modifier.isStatic;
+import static org.junit.internal.MethodSorter.NAME_ASCENDING;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.internal.MethodSorter;
+
+/**
+ * Wraps a class to be run, providing method validation and annotation searching
+ *
+ * @since 4.5
+ */
+public class TestClass implements Annotatable {
+    private static final FieldComparator FIELD_COMPARATOR = new FieldComparator();
+    private static final MethodComparator METHOD_COMPARATOR = new MethodComparator();
+
+    private final Class<?> clazz;
+    private final Map<Class<? extends Annotation>, List<FrameworkMethod>> methodsForAnnotations;
+    private final Map<Class<? extends Annotation>, List<FrameworkField>> fieldsForAnnotations;
+
+    /**
+     * Creates a {@code TestClass} wrapping {@code clazz}. Each time this
+     * constructor executes, the class is scanned for annotations, which can be
+     * an expensive process (we hope in future JDK's it will not be.) Therefore,
+     * try to share instances of {@code TestClass} where possible.
+     */
+    public TestClass(Class<?> clazz) {
+        this.clazz = clazz;
+        if (clazz != null && clazz.getConstructors().length > 1) {
+            throw new IllegalArgumentException(
+                    "Test class can only have one constructor");
+        }
+
+        Map<Class<? extends Annotation>, List<FrameworkMethod>> methodsForAnnotations =
+                new LinkedHashMap<Class<? extends Annotation>, List<FrameworkMethod>>();
+        Map<Class<? extends Annotation>, List<FrameworkField>> fieldsForAnnotations =
+                new LinkedHashMap<Class<? extends Annotation>, List<FrameworkField>>();
+
+        scanAnnotatedMembers(methodsForAnnotations, fieldsForAnnotations);
+
+        this.methodsForAnnotations = makeDeeplyUnmodifiable(methodsForAnnotations);
+        this.fieldsForAnnotations = makeDeeplyUnmodifiable(fieldsForAnnotations);
+    }
+
+    protected void scanAnnotatedMembers(Map<Class<? extends Annotation>, List<FrameworkMethod>> methodsForAnnotations, Map<Class<? extends Annotation>, List<FrameworkField>> fieldsForAnnotations) {
+        for (Class<?> eachClass : getSuperClasses(clazz)) {
+            for (Method eachMethod : MethodSorter.getDeclaredMethods(eachClass)) {
+                addToAnnotationLists(new FrameworkMethod(eachMethod), methodsForAnnotations);
+            }
+            // ensuring fields are sorted to make sure that entries are inserted
+            // and read from fieldForAnnotations in a deterministic order
+            for (Field eachField : getSortedDeclaredFields(eachClass)) {
+                addToAnnotationLists(new FrameworkField(eachField), fieldsForAnnotations);
+            }
+        }
+    }
+
+    private static Field[] getSortedDeclaredFields(Class<?> clazz) {
+        Field[] declaredFields = clazz.getDeclaredFields();
+        // TODO(b/66985866) - uncomment when affected tests have Rule order fixed.
+        // Arrays.sort(declaredFields, FIELD_COMPARATOR);
+        return declaredFields;
+    }
+
+    protected static <T extends FrameworkMember<T>> void addToAnnotationLists(T member,
+            Map<Class<? extends Annotation>, List<T>> map) {
+        for (Annotation each : member.getAnnotations()) {
+            Class<? extends Annotation> type = each.annotationType();
+            List<T> members = getAnnotatedMembers(map, type, true);
+            T memberToAdd = member.handlePossibleBridgeMethod(members);
+            if (memberToAdd == null) {
+                return;
+            }
+            if (runsTopToBottom(type)) {
+                members.add(0, memberToAdd);
+            } else {
+                members.add(memberToAdd);
+            }
+        }
+    }
+
+    private static <T extends FrameworkMember<T>> Map<Class<? extends Annotation>, List<T>>
+            makeDeeplyUnmodifiable(Map<Class<? extends Annotation>, List<T>> source) {
+        Map<Class<? extends Annotation>, List<T>> copy =
+                new LinkedHashMap<Class<? extends Annotation>, List<T>>();
+        for (Map.Entry<Class<? extends Annotation>, List<T>> entry : source.entrySet()) {
+            copy.put(entry.getKey(), Collections.unmodifiableList(entry.getValue()));
+        }
+        return Collections.unmodifiableMap(copy);
+    }
+
+    /**
+     * Returns, efficiently, all the non-overridden methods in this class and
+     * its superclasses that are annotated}.
+     * 
+     * @since 4.12
+     */
+    public List<FrameworkMethod> getAnnotatedMethods() {
+        List<FrameworkMethod> methods = collectValues(methodsForAnnotations);
+        Collections.sort(methods, METHOD_COMPARATOR);
+        return methods;
+    }
+
+    /**
+     * Returns, efficiently, all the non-overridden methods in this class and
+     * its superclasses that are annotated with {@code annotationClass}.
+     */
+    public List<FrameworkMethod> getAnnotatedMethods(
+            Class<? extends Annotation> annotationClass) {
+        return Collections.unmodifiableList(getAnnotatedMembers(methodsForAnnotations, annotationClass, false));
+    }
+
+    /**
+     * Returns, efficiently, all the non-overridden fields in this class and its
+     * superclasses that are annotated.
+     * 
+     * @since 4.12
+     */
+    public List<FrameworkField> getAnnotatedFields() {
+        return collectValues(fieldsForAnnotations);
+    }
+
+    /**
+     * Returns, efficiently, all the non-overridden fields in this class and its
+     * superclasses that are annotated with {@code annotationClass}.
+     */
+    public List<FrameworkField> getAnnotatedFields(
+            Class<? extends Annotation> annotationClass) {
+        return Collections.unmodifiableList(getAnnotatedMembers(fieldsForAnnotations, annotationClass, false));
+    }
+
+    private <T> List<T> collectValues(Map<?, List<T>> map) {
+        Set<T> values = new LinkedHashSet<T>();
+        for (List<T> additionalValues : map.values()) {
+            values.addAll(additionalValues);
+        }
+        return new ArrayList<T>(values);
+    }
+
+    private static <T> List<T> getAnnotatedMembers(Map<Class<? extends Annotation>, List<T>> map,
+            Class<? extends Annotation> type, boolean fillIfAbsent) {
+        if (!map.containsKey(type) && fillIfAbsent) {
+            map.put(type, new ArrayList<T>());
+        }
+        List<T> members = map.get(type);
+        return members == null ? Collections.<T>emptyList() : members;
+    }
+
+    private static boolean runsTopToBottom(Class<? extends Annotation> annotation) {
+        return annotation.equals(Before.class)
+                || annotation.equals(BeforeClass.class);
+    }
+
+    private static List<Class<?>> getSuperClasses(Class<?> testClass) {
+        List<Class<?>> results = new ArrayList<Class<?>>();
+        Class<?> current = testClass;
+        while (current != null) {
+            results.add(current);
+            current = current.getSuperclass();
+        }
+        return results;
+    }
+
+    /**
+     * Returns the underlying Java class.
+     */
+    public Class<?> getJavaClass() {
+        return clazz;
+    }
+
+    /**
+     * Returns the class's name.
+     */
+    public String getName() {
+        if (clazz == null) {
+            return "null";
+        }
+        return clazz.getName();
+    }
+
+    /**
+     * Returns the only public constructor in the class, or throws an {@code
+     * AssertionError} if there are more or less than one.
+     */
+
+    public Constructor<?> getOnlyConstructor() {
+        Constructor<?>[] constructors = clazz.getConstructors();
+        Assert.assertEquals(1, constructors.length);
+        return constructors[0];
+    }
+
+    /**
+     * Returns the annotations on this class
+     */
+    public Annotation[] getAnnotations() {
+        if (clazz == null) {
+            return new Annotation[0];
+        }
+        return clazz.getAnnotations();
+    }
+
+    public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
+        if (clazz == null) {
+            return null;
+        }
+        return clazz.getAnnotation(annotationType);
+    }
+
+    public <T> List<T> getAnnotatedFieldValues(Object test,
+            Class<? extends Annotation> annotationClass, Class<T> valueClass) {
+        final List<T> results = new ArrayList<T>();
+        collectAnnotatedFieldValues(test, annotationClass, valueClass,
+                new MemberValueConsumer<T>() {
+                    public void accept(FrameworkMember<?> member, T value) {
+                        results.add(value);
+                    }
+                });
+        return results;
+    }
+
+    /**
+     * Finds the fields annotated with the specified annotation and having the specified type,
+     * retrieves the values and passes those to the specified consumer.
+     *
+     * @since 4.13
+     */
+    public <T> void collectAnnotatedFieldValues(Object test,
+            Class<? extends Annotation> annotationClass, Class<T> valueClass,
+            MemberValueConsumer<T> consumer) {
+        for (FrameworkField each : getAnnotatedFields(annotationClass)) {
+            try {
+                Object fieldValue = each.get(test);
+                if (valueClass.isInstance(fieldValue)) {
+                    consumer.accept(each, valueClass.cast(fieldValue));
+                }
+            } catch (IllegalAccessException e) {
+                throw new RuntimeException(
+                        "How did getFields return a field we couldn't access?", e);
+            }
+        }
+    }
+
+    public <T> List<T> getAnnotatedMethodValues(Object test,
+            Class<? extends Annotation> annotationClass, Class<T> valueClass) {
+        final List<T> results = new ArrayList<T>();
+        collectAnnotatedMethodValues(test, annotationClass, valueClass,
+                new MemberValueConsumer<T>() {
+                    public void accept(FrameworkMember<?> member, T value) {
+                        results.add(value);
+                    }
+                });
+        return results;
+    }
+
+    /**
+     * Finds the methods annotated with the specified annotation and returning the specified type,
+     * invokes it and pass the return value to the specified consumer.
+     *
+     * @since 4.13
+     */
+    public <T> void collectAnnotatedMethodValues(Object test,
+            Class<? extends Annotation> annotationClass, Class<T> valueClass,
+            MemberValueConsumer<T> consumer) {
+        for (FrameworkMethod each : getAnnotatedMethods(annotationClass)) {
+            try {
+                /*
+                 * A method annotated with @Rule may return a @TestRule or a @MethodRule,
+                 * we cannot call the method to check whether the return type matches our
+                 * expectation i.e. subclass of valueClass. If we do that then the method 
+                 * will be invoked twice and we do not want to do that. So we first check
+                 * whether return type matches our expectation and only then call the method
+                 * to fetch the MethodRule
+                 */
+                if (valueClass.isAssignableFrom(each.getReturnType())) {
+                    Object fieldValue = each.invokeExplosively(test);
+                    consumer.accept(each, valueClass.cast(fieldValue));
+                }
+            } catch (Throwable e) {
+                throw new RuntimeException(
+                        "Exception in " + each.getName(), e);
+            }
+        }
+    }
+
+    public boolean isPublic() {
+        return Modifier.isPublic(clazz.getModifiers());
+    }
+
+    public boolean isANonStaticInnerClass() {
+        return clazz.isMemberClass() && !isStatic(clazz.getModifiers());
+    }
+
+    @Override
+    public int hashCode() {
+        return (clazz == null) ? 0 : clazz.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        TestClass other = (TestClass) obj;
+        return clazz == other.clazz;
+    }
+
+    /**
+     * Compares two fields by its name.
+     */
+    private static class FieldComparator implements Comparator<Field> {
+        public int compare(Field left, Field right) {
+            return left.getName().compareTo(right.getName());
+        }
+    }
+
+    /**
+     * Compares two methods by its name.
+     */
+    private static class MethodComparator implements
+            Comparator<FrameworkMethod> {
+        public int compare(FrameworkMethod left, FrameworkMethod right) {
+            return NAME_ASCENDING.compare(left.getMethod(), right.getMethod());
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/model/TestTimedOutException.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/TestTimedOutException.java
new file mode 100644
index 0000000..60e1a8a
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/model/TestTimedOutException.java
@@ -0,0 +1,44 @@
+package org.junit.runners.model;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Exception thrown when a test fails on timeout.
+ * 
+ * @since 4.12
+ * 
+ */
+public class TestTimedOutException extends Exception {
+
+    private static final long serialVersionUID = 31935685163547539L;
+
+    private final TimeUnit timeUnit;
+    private final long timeout;
+
+    /**
+     * Creates exception with a standard message "test timed out after [timeout] [timeUnit]"
+     * 
+     * @param timeout the amount of time passed before the test was interrupted
+     * @param timeUnit the time unit for the timeout value
+     */
+    public TestTimedOutException(long timeout, TimeUnit timeUnit) {
+        super(String.format("test timed out after %d %s", 
+                timeout, timeUnit.name().toLowerCase()));
+        this.timeUnit = timeUnit;
+        this.timeout = timeout;
+    }
+
+    /**
+     * Gets the time passed before the test was interrupted
+     */
+    public long getTimeout() {
+        return timeout;
+    }
+
+    /**
+     * Gets the time unit for the timeout value
+     */
+    public TimeUnit getTimeUnit() {
+        return timeUnit;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/package-info.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/package-info.java
new file mode 100644
index 0000000..418acaf
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/package-info.java
@@ -0,0 +1,8 @@
+/**
+ * Provides standard {@link org.junit.runner.Runner Runner} implementations.
+ *
+ * @since 4.0
+ * @see org.junit.runner.Runner
+ * @see org.junit.runners.BlockJUnit4ClassRunner
+ */
+package org.junit.runners;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParameters.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParameters.java
new file mode 100644
index 0000000..5c70a75
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParameters.java
@@ -0,0 +1,219 @@
+package org.junit.runners.parameterized;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.util.List;
+
+import org.junit.internal.runners.statements.RunAfters;
+import org.junit.internal.runners.statements.RunBefores;
+import org.junit.runner.RunWith;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.model.FrameworkField;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+
+/**
+ * A {@link BlockJUnit4ClassRunner} with parameters support. Parameters can be
+ * injected via constructor or into annotated fields.
+ */
+public class BlockJUnit4ClassRunnerWithParameters extends
+        BlockJUnit4ClassRunner {
+    private enum InjectionType {
+        CONSTRUCTOR, FIELD
+    }
+
+    private final Object[] parameters;
+
+    private final String name;
+
+    public BlockJUnit4ClassRunnerWithParameters(TestWithParameters test)
+            throws InitializationError {
+        super(test.getTestClass());
+        parameters = test.getParameters().toArray(
+                new Object[test.getParameters().size()]);
+        name = test.getName();
+    }
+
+    @Override
+    public Object createTest() throws Exception {
+        InjectionType injectionType = getInjectionType();
+        switch (injectionType) {
+            case CONSTRUCTOR:
+                return createTestUsingConstructorInjection();
+            case FIELD:
+                return createTestUsingFieldInjection();
+            default:
+                throw new IllegalStateException("The injection type "
+                        + injectionType + " is not supported.");
+        }
+    }
+
+    private Object createTestUsingConstructorInjection() throws Exception {
+        return getTestClass().getOnlyConstructor().newInstance(parameters);
+    }
+
+    private Object createTestUsingFieldInjection() throws Exception {
+        List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
+        if (annotatedFieldsByParameter.size() != parameters.length) {
+            throw new Exception(
+                    "Wrong number of parameters and @Parameter fields."
+                            + " @Parameter fields counted: "
+                            + annotatedFieldsByParameter.size()
+                            + ", available parameters: " + parameters.length
+                            + ".");
+        }
+        Object testClassInstance = getTestClass().getJavaClass().newInstance();
+        for (FrameworkField each : annotatedFieldsByParameter) {
+            Field field = each.getField();
+            Parameter annotation = field.getAnnotation(Parameter.class);
+            int index = annotation.value();
+            try {
+                field.set(testClassInstance, parameters[index]);
+            } catch (IllegalAccessException e) {
+                IllegalAccessException wrappedException = new IllegalAccessException(
+                        "Cannot set parameter '" + field.getName()
+                                + "'. Ensure that the field '" + field.getName()
+                                + "' is public.");
+                wrappedException.initCause(e);
+                throw wrappedException;
+            } catch (IllegalArgumentException iare) {
+                throw new Exception(getTestClass().getName()
+                        + ": Trying to set " + field.getName()
+                        + " with the value " + parameters[index]
+                        + " that is not the right type ("
+                        + parameters[index].getClass().getSimpleName()
+                        + " instead of " + field.getType().getSimpleName()
+                        + ").", iare);
+            }
+        }
+        return testClassInstance;
+    }
+
+    @Override
+    protected String getName() {
+        return name;
+    }
+
+    @Override
+    protected String testName(FrameworkMethod method) {
+        return method.getName() + getName();
+    }
+
+    @Override
+    protected void validateConstructor(List<Throwable> errors) {
+        validateOnlyOneConstructor(errors);
+        if (getInjectionType() != InjectionType.CONSTRUCTOR) {
+            validateZeroArgConstructor(errors);
+        }
+    }
+
+    @Override
+    protected void validateFields(List<Throwable> errors) {
+        super.validateFields(errors);
+        if (getInjectionType() == InjectionType.FIELD) {
+            List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
+            int[] usedIndices = new int[annotatedFieldsByParameter.size()];
+            for (FrameworkField each : annotatedFieldsByParameter) {
+                int index = each.getField().getAnnotation(Parameter.class)
+                        .value();
+                if (index < 0 || index > annotatedFieldsByParameter.size() - 1) {
+                    errors.add(new Exception("Invalid @Parameter value: "
+                            + index + ". @Parameter fields counted: "
+                            + annotatedFieldsByParameter.size()
+                            + ". Please use an index between 0 and "
+                            + (annotatedFieldsByParameter.size() - 1) + "."));
+                } else {
+                    usedIndices[index]++;
+                }
+            }
+            for (int index = 0; index < usedIndices.length; index++) {
+                int numberOfUse = usedIndices[index];
+                if (numberOfUse == 0) {
+                    errors.add(new Exception("@Parameter(" + index
+                            + ") is never used."));
+                } else if (numberOfUse > 1) {
+                    errors.add(new Exception("@Parameter(" + index
+                            + ") is used more than once (" + numberOfUse + ")."));
+                }
+            }
+        }
+    }
+
+    @Override
+    protected Statement classBlock(RunNotifier notifier) {
+        Statement statement = childrenInvoker(notifier);
+        statement = withBeforeParams(statement);
+        statement = withAfterParams(statement);
+        return statement;
+    }
+
+    private Statement withBeforeParams(Statement statement) {
+        List<FrameworkMethod> befores = getTestClass()
+                .getAnnotatedMethods(Parameterized.BeforeParam.class);
+        return befores.isEmpty() ? statement : new RunBeforeParams(statement, befores);
+    }
+
+    private class RunBeforeParams extends RunBefores {
+        RunBeforeParams(Statement next, List<FrameworkMethod> befores) {
+            super(next, befores, null);
+        }
+
+        @Override
+        protected void invokeMethod(FrameworkMethod method) throws Throwable {
+            int paramCount = method.getMethod().getParameterTypes().length;
+            method.invokeExplosively(null, paramCount == 0 ? (Object[]) null : parameters);
+        }
+    }
+
+    private Statement withAfterParams(Statement statement) {
+        List<FrameworkMethod> afters = getTestClass()
+                .getAnnotatedMethods(Parameterized.AfterParam.class);
+        return afters.isEmpty() ? statement : new RunAfterParams(statement, afters);
+    }
+
+    private class RunAfterParams extends RunAfters {
+        RunAfterParams(Statement next, List<FrameworkMethod> afters) {
+            super(next, afters, null);
+        }
+
+        @Override
+        protected void invokeMethod(FrameworkMethod method) throws Throwable {
+            int paramCount = method.getMethod().getParameterTypes().length;
+            method.invokeExplosively(null, paramCount == 0 ? (Object[]) null : parameters);
+        }
+    }
+
+    @Override
+    protected Annotation[] getRunnerAnnotations() {
+        Annotation[] allAnnotations = super.getRunnerAnnotations();
+        Annotation[] annotationsWithoutRunWith = new Annotation[allAnnotations.length - 1];
+        int i = 0;
+        for (Annotation annotation: allAnnotations) {
+            if (!annotation.annotationType().equals(RunWith.class)) {
+                annotationsWithoutRunWith[i] = annotation;
+                ++i;
+            }
+        }
+        return annotationsWithoutRunWith;
+    }
+
+    private List<FrameworkField> getAnnotatedFieldsByParameter() {
+        return getTestClass().getAnnotatedFields(Parameter.class);
+    }
+
+    private InjectionType getInjectionType() {
+        if (fieldsAreAnnotated()) {
+            return InjectionType.FIELD;
+        } else {
+            return InjectionType.CONSTRUCTOR;
+        }
+    }
+
+    private boolean fieldsAreAnnotated() {
+        return !getAnnotatedFieldsByParameter().isEmpty();
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParametersFactory.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParametersFactory.java
new file mode 100644
index 0000000..ae49ef4
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParametersFactory.java
@@ -0,0 +1,18 @@
+package org.junit.runners.parameterized;
+
+import org.junit.runner.Runner;
+import org.junit.runners.model.InitializationError;
+
+/**
+ * A {@link ParametersRunnerFactory} that creates
+ * {@link BlockJUnit4ClassRunnerWithParameters}.
+ * 
+ * @since 4.12
+ */
+public class BlockJUnit4ClassRunnerWithParametersFactory implements
+        ParametersRunnerFactory {
+    public Runner createRunnerForTestWithParameters(TestWithParameters test)
+            throws InitializationError {
+        return new BlockJUnit4ClassRunnerWithParameters(test);
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/ParametersRunnerFactory.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/ParametersRunnerFactory.java
new file mode 100644
index 0000000..8123e83
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/ParametersRunnerFactory.java
@@ -0,0 +1,21 @@
+package org.junit.runners.parameterized;
+
+import org.junit.runner.Runner;
+import org.junit.runners.model.InitializationError;
+
+/**
+ * A {@code ParametersRunnerFactory} creates a runner for a single
+ * {@link TestWithParameters}.
+ * 
+ * @since 4.12
+ */
+public interface ParametersRunnerFactory {
+    /**
+     * Returns a runner for the specified {@link TestWithParameters}.
+     * 
+     * @throws InitializationError
+     *             if the runner could not be created.
+     */
+    Runner createRunnerForTestWithParameters(TestWithParameters test)
+            throws InitializationError;
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/TestWithParameters.java b/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/TestWithParameters.java
new file mode 100644
index 0000000..1c5abd9
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/runners/parameterized/TestWithParameters.java
@@ -0,0 +1,77 @@
+package org.junit.runners.parameterized;
+
+import static java.util.Collections.unmodifiableList;
+import static org.junit.internal.Checks.notNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.runners.model.TestClass;
+
+/**
+ * A {@code TestWithParameters} keeps the data together that are needed for
+ * creating a runner for a single data set of a parameterized test. It has a
+ * name, the test class and a list of parameters.
+ * 
+ * @since 4.12
+ */
+public class TestWithParameters {
+    private final String name;
+
+    private final TestClass testClass;
+
+    private final List<Object> parameters;
+
+    public TestWithParameters(String name, TestClass testClass,
+            List<Object> parameters) {
+        notNull(name, "The name is missing.");
+        notNull(testClass, "The test class is missing.");
+        notNull(parameters, "The parameters are missing.");
+        this.name = name;
+        this.testClass = testClass;
+        this.parameters = unmodifiableList(new ArrayList<Object>(parameters));
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public TestClass getTestClass() {
+        return testClass;
+    }
+
+    public List<Object> getParameters() {
+        return parameters;
+    }
+
+    @Override
+    public int hashCode() {
+        int prime = 14747;
+        int result = prime + name.hashCode();
+        result = prime * result + testClass.hashCode();
+        return prime * result + parameters.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        TestWithParameters other = (TestWithParameters) obj;
+        return name.equals(other.name)
+                && parameters.equals(other.parameters)
+                && testClass.equals(other.testClass);
+    }
+
+    @Override
+    public String toString() {
+        return testClass.getName() + " '" + name + "' with parameters "
+                + parameters;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/validator/AnnotationValidator.java b/google3/third_party/java_src/junit/main/java/org/junit/validator/AnnotationValidator.java
new file mode 100644
index 0000000..8a53adf
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/validator/AnnotationValidator.java
@@ -0,0 +1,60 @@
+package org.junit.validator;
+
+import org.junit.runners.model.FrameworkField;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.TestClass;
+
+import static java.util.Collections.emptyList;
+
+import java.util.List;
+
+/**
+ * Validates annotations on classes and methods. To be validated,
+ * an annotation should be annotated with {@link ValidateWith}
+ *
+ * Instances of this class are shared by multiple test runners, so they should
+ * be immutable and thread-safe.
+ *
+ * @since 4.12
+ */
+public abstract class AnnotationValidator {
+
+    private static final List<Exception> NO_VALIDATION_ERRORS = emptyList();
+
+    /**
+     * Validates annotation on the given class.
+     *
+     * @param testClass that is being validated
+     * @return A list of exceptions. Default behavior is to return an empty list.
+     *
+     * @since 4.12
+     */
+    public List<Exception> validateAnnotatedClass(TestClass testClass) {
+        return NO_VALIDATION_ERRORS;
+    }
+
+    /**
+     * Validates annotation on the given field.
+     *
+     * @param field that is being validated
+     * @return A list of exceptions. Default behavior is to return an empty list.
+     *
+     * @since 4.12
+     */
+    public List<Exception> validateAnnotatedField(FrameworkField field) {
+        return NO_VALIDATION_ERRORS;
+
+    }
+
+    /**
+     * Validates annotation on the given method.
+     *
+     * @param method that is being validated
+     * @return A list of exceptions. Default behavior is to return an empty list.
+     *
+     * @since 4.12
+     */
+    public List<Exception> validateAnnotatedMethod(FrameworkMethod method) {
+        return NO_VALIDATION_ERRORS;
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/validator/AnnotationValidatorFactory.java b/google3/third_party/java_src/junit/main/java/org/junit/validator/AnnotationValidatorFactory.java
new file mode 100644
index 0000000..fb2460d
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/validator/AnnotationValidatorFactory.java
@@ -0,0 +1,39 @@
+package org.junit.validator;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Creates instances of Annotation Validators.
+ *
+ * @since 4.12
+ */
+public class AnnotationValidatorFactory {
+    private static final ConcurrentHashMap<ValidateWith, AnnotationValidator> VALIDATORS_FOR_ANNOTATION_TYPES =
+            new ConcurrentHashMap<ValidateWith, AnnotationValidator>();
+
+    /**
+     * Creates the AnnotationValidator specified by the value in
+     * {@link org.junit.validator.ValidateWith}. Instances are
+     * cached.
+     *
+     * @return An instance of the AnnotationValidator.
+     *
+     * @since 4.12
+     */
+    public AnnotationValidator createAnnotationValidator(ValidateWith validateWithAnnotation) {
+        AnnotationValidator validator = VALIDATORS_FOR_ANNOTATION_TYPES.get(validateWithAnnotation);
+        if (validator != null) {
+            return validator;
+        }
+
+        Class<? extends AnnotationValidator> clazz = validateWithAnnotation.value();
+        try {
+            AnnotationValidator annotationValidator = clazz.newInstance();
+            VALIDATORS_FOR_ANNOTATION_TYPES.putIfAbsent(validateWithAnnotation, annotationValidator);
+            return VALIDATORS_FOR_ANNOTATION_TYPES.get(validateWithAnnotation);
+        } catch (Exception e) {
+            throw new RuntimeException("Exception received when creating AnnotationValidator class " + clazz.getName(), e);
+        }
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/validator/AnnotationsValidator.java b/google3/third_party/java_src/junit/main/java/org/junit/validator/AnnotationsValidator.java
new file mode 100644
index 0000000..d8b5840
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/validator/AnnotationsValidator.java
@@ -0,0 +1,120 @@
+package org.junit.validator;
+
+import static java.util.Collections.singletonList;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.runners.model.Annotatable;
+import org.junit.runners.model.FrameworkField;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.TestClass;
+
+/**
+ * An {@code AnnotationsValidator} validates all annotations of a test class,
+ * including its annotated fields and methods.
+ * 
+ * @since 4.12
+ */
+public final class AnnotationsValidator implements TestClassValidator {
+    private static final List<AnnotatableValidator<?>> VALIDATORS = Arrays.<AnnotatableValidator<?>>asList(
+            new ClassValidator(), new MethodValidator(), new FieldValidator());
+
+    /**
+     * Validate all annotations of the specified test class that are be
+     * annotated with {@link ValidateWith}.
+     * 
+     * @param testClass
+     *            the {@link TestClass} that is validated.
+     * @return the errors found by the validator.
+     */
+    public List<Exception> validateTestClass(TestClass testClass) {
+        List<Exception> validationErrors= new ArrayList<Exception>();
+        for (AnnotatableValidator<?> validator : VALIDATORS) {
+            List<Exception> additionalErrors= validator
+                    .validateTestClass(testClass);
+            validationErrors.addAll(additionalErrors);
+        }
+        return validationErrors;
+    }
+
+    private abstract static class AnnotatableValidator<T extends Annotatable> {
+        private static final AnnotationValidatorFactory ANNOTATION_VALIDATOR_FACTORY = new AnnotationValidatorFactory();
+
+        abstract Iterable<T> getAnnotatablesForTestClass(TestClass testClass);
+
+        abstract List<Exception> validateAnnotatable(
+                AnnotationValidator validator, T annotatable);
+
+        public List<Exception> validateTestClass(TestClass testClass) {
+            List<Exception> validationErrors= new ArrayList<Exception>();
+            for (T annotatable : getAnnotatablesForTestClass(testClass)) {
+                List<Exception> additionalErrors= validateAnnotatable(annotatable);
+                validationErrors.addAll(additionalErrors);
+            }
+            return validationErrors;
+        }
+
+        private List<Exception> validateAnnotatable(T annotatable) {
+            List<Exception> validationErrors= new ArrayList<Exception>();
+            for (Annotation annotation : annotatable.getAnnotations()) {
+                Class<? extends Annotation> annotationType = annotation
+                        .annotationType();
+                ValidateWith validateWith = annotationType
+                        .getAnnotation(ValidateWith.class);
+                if (validateWith != null) {
+                    AnnotationValidator annotationValidator = ANNOTATION_VALIDATOR_FACTORY
+                            .createAnnotationValidator(validateWith);
+                    List<Exception> errors= validateAnnotatable(
+                            annotationValidator, annotatable);
+                    validationErrors.addAll(errors);
+                }
+            }
+            return validationErrors;
+        }
+    }
+
+    private static class ClassValidator extends AnnotatableValidator<TestClass> {
+        @Override
+        Iterable<TestClass> getAnnotatablesForTestClass(TestClass testClass) {
+            return singletonList(testClass);
+        }
+
+        @Override
+        List<Exception> validateAnnotatable(
+                AnnotationValidator validator, TestClass testClass) {
+            return validator.validateAnnotatedClass(testClass);
+        }
+    }
+
+    private static class MethodValidator extends
+            AnnotatableValidator<FrameworkMethod> {
+        @Override
+        Iterable<FrameworkMethod> getAnnotatablesForTestClass(
+                TestClass testClass) {
+            return testClass.getAnnotatedMethods();
+        }
+
+        @Override
+        List<Exception> validateAnnotatable(
+                AnnotationValidator validator, FrameworkMethod method) {
+            return validator.validateAnnotatedMethod(method);
+        }
+    }
+
+    private static class FieldValidator extends
+            AnnotatableValidator<FrameworkField> {
+        @Override
+        Iterable<FrameworkField> getAnnotatablesForTestClass(TestClass testClass) {
+            return testClass.getAnnotatedFields();
+        }
+
+        @Override
+        List<Exception> validateAnnotatable(
+                AnnotationValidator validator, FrameworkField field) {
+            return validator.validateAnnotatedField(field);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/validator/PublicClassValidator.java b/google3/third_party/java_src/junit/main/java/org/junit/validator/PublicClassValidator.java
new file mode 100644
index 0000000..fe3f185
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/validator/PublicClassValidator.java
@@ -0,0 +1,33 @@
+package org.junit.validator;
+
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
+
+import java.util.List;
+
+import org.junit.runners.model.TestClass;
+
+/**
+ * Validates that a {@link TestClass} is public.
+ * 
+ * @since 4.12
+ */
+public class PublicClassValidator implements TestClassValidator {
+    private static final List<Exception> NO_VALIDATION_ERRORS = emptyList();
+
+    /**
+     * Validate that the specified {@link TestClass} is public.
+     * 
+     * @param testClass the {@link TestClass} that is validated.
+     * @return an empty list if the class is public or a list with a single
+     *         exception otherwise.
+     */
+    public List<Exception> validateTestClass(TestClass testClass) {
+        if (testClass.isPublic()) {
+            return NO_VALIDATION_ERRORS;
+        } else {
+            return singletonList(new Exception("The class "
+                    + testClass.getName() + " is not public."));
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/validator/TestClassValidator.java b/google3/third_party/java_src/junit/main/java/org/junit/validator/TestClassValidator.java
new file mode 100644
index 0000000..ba5e892
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/validator/TestClassValidator.java
@@ -0,0 +1,21 @@
+package org.junit.validator;
+
+import java.util.List;
+
+import org.junit.runners.model.TestClass;
+
+/**
+ * Validates a single facet of a test class.
+ * 
+ * @since 4.12
+ */
+public interface TestClassValidator {
+    /**
+     * Validate a single facet of a test class.
+     * 
+     * @param testClass
+     *            the {@link TestClass} that is validated.
+     * @return the validation errors found by the validator.
+     */
+    List<Exception> validateTestClass(TestClass testClass);
+}
diff --git a/google3/third_party/java_src/junit/main/java/org/junit/validator/ValidateWith.java b/google3/third_party/java_src/junit/main/java/org/junit/validator/ValidateWith.java
new file mode 100644
index 0000000..3725db8
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/java/org/junit/validator/ValidateWith.java
@@ -0,0 +1,22 @@
+package org.junit.validator;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Allows for an {@link AnnotationValidator} to be attached to an annotation.
+ *
+ * <p>When attached to an annotation, the validator will be instantiated and invoked
+ * by the {@link org.junit.runners.ParentRunner}.</p>
+ *
+ * @since 4.12
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.ANNOTATION_TYPE)
+@Inherited
+public @interface ValidateWith {
+    Class<? extends AnnotationValidator> value();
+}
diff --git a/google3/third_party/java_src/junit/main/javadoc/stylesheet.css b/google3/third_party/java_src/junit/main/javadoc/stylesheet.css
new file mode 100644
index 0000000..ab56778
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/javadoc/stylesheet.css
@@ -0,0 +1,25 @@
+/* Javadoc style sheet */
+/* makes unvisited links red (red bad) */
+A {color:red;}
+/* makes visited links the same green as the toolbar (green good) */
+A:visited {color:#03A35D;}            
+/* Define colors, fonts and other style attributes here to override the defaults  */
+/* Page background color */
+body { background-color: #FFFFFF }
+/* Table colors */
+.TableHeadingColor     { background: #03A35D} /* Green */
+.TableSubHeadingColor  { background: #03A35D } /* Green */
+.TableRowColor         { background: #FFFFFF } /* White */
+/* Font used in left-hand frame lists */
+.FrameTitleFont   { font-size: normal; font-family: normal }
+.FrameHeadingFont { font-size: normal; font-family: normal }
+.FrameItemFont    { font-size: normal; font-family: normal }
+/* Example of smaller, sans-serif font in frames */
+/* .FrameItemFont  { font-size: 10pt; font-family: Helvetica, Arial, sans-serif } */
+/* Navigation bar fonts and colors */
+.NavBarCell1    { background-color:#03A35D;}/* Green */
+.NavBarCell1Rev { background-color:#006400;}/* Dark green */
+.NavBarFont1    { font-family: Arial, Helvetica, sans-serif; color:#000000;}
+.NavBarFont1Rev { font-family: Arial, Helvetica, sans-serif; color:#FFFFFF;}
+.NavBarCell2    { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF;}
+.NavBarCell3    { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF;}
diff --git a/google3/third_party/java_src/junit/main/resources/junit/runner/logo.gif b/google3/third_party/java_src/junit/main/resources/junit/runner/logo.gif
new file mode 100644
index 0000000..d0e1547
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/resources/junit/runner/logo.gif
Binary files differ
diff --git a/google3/third_party/java_src/junit/main/resources/junit/runner/smalllogo.gif b/google3/third_party/java_src/junit/main/resources/junit/runner/smalllogo.gif
new file mode 100644
index 0000000..7b25eaf
--- /dev/null
+++ b/google3/third_party/java_src/junit/main/resources/junit/runner/smalllogo.gif
Binary files differ
diff --git a/google3/third_party/java_src/junit/test/java/junit/samples/AllTests.java b/google3/third_party/java_src/junit/test/java/junit/samples/AllTests.java
new file mode 100644
index 0000000..6307404
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/samples/AllTests.java
@@ -0,0 +1,22 @@
+package junit.samples;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * TestSuite that runs all the sample tests
+ */
+public class AllTests {
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite("All JUnit Tests");
+        suite.addTest(ListTest.suite());
+        suite.addTest(new TestSuite(junit.samples.money.MoneyTest.class));
+        suite.addTest(junit.tests.AllTests.suite());
+        return suite;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/samples/ListTest.java b/google3/third_party/java_src/junit/test/java/junit/samples/ListTest.java
new file mode 100644
index 0000000..324f12b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/samples/ListTest.java
@@ -0,0 +1,67 @@
+package junit.samples;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+ * A sample test case, testing {@link java.util.ArrayList}.
+ */
+public class ListTest extends TestCase {
+    private List<Integer> emptyList;
+    private List<Integer> fullList;
+
+
+    @Override
+    protected void setUp() {
+        emptyList = new ArrayList<Integer>();
+        fullList = new ArrayList<Integer>();
+        fullList.add(1);
+        fullList.add(2);
+        fullList.add(3);
+    }
+
+    public static Test suite() {
+        return new TestSuite(ListTest.class);
+    }
+
+    public void testCapacity() {
+        int size = fullList.size();
+        for (int i = 0; i < 100; i++) {
+            fullList.add(i);
+        }
+        assertTrue(fullList.size() == 100 + size);
+    }
+
+    public void testContains() {
+        assertTrue(fullList.contains(1));
+        assertFalse(emptyList.contains(1));
+    }
+
+    public void testElementAt() {
+        int i = fullList.get(0);
+        assertEquals(1,i);
+
+        try {
+            fullList.get(fullList.size());
+        } catch (IndexOutOfBoundsException e) {
+            return;
+        }
+        fail("Should raise an ArrayIndexOutOfBoundsException");
+    }
+
+    public void testRemoveAll() {
+        fullList.removeAll(fullList);
+        emptyList.removeAll(emptyList);
+        assertTrue(fullList.isEmpty());
+        assertTrue(emptyList.isEmpty());
+    }
+
+    public void testRemoveElement() {
+        fullList.remove(Integer.valueOf(3));
+        assertFalse(fullList.contains(3));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/samples/SimpleTest.java b/google3/third_party/java_src/junit/test/java/junit/samples/SimpleTest.java
new file mode 100644
index 0000000..5177f48
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/samples/SimpleTest.java
@@ -0,0 +1,72 @@
+package junit.samples;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+ * Some simple tests.
+ */
+public class SimpleTest extends TestCase {
+    protected int fValue1;
+    protected int fValue2;
+
+    @Override
+    protected void setUp() {
+        fValue1 = 2;
+        fValue2 = 3;
+    }
+
+    public static Test suite() {
+
+        /*
+           * the type safe way
+           *
+          TestSuite suite= new TestSuite();
+          suite.addTest(
+              new SimpleTest("add") {
+                   protected void runTest() { testAdd(); }
+              }
+          );
+
+          suite.addTest(
+              new SimpleTest("testDivideByZero") {
+                   protected void runTest() { testDivideByZero(); }
+              }
+          );
+          return suite;
+          */
+
+        /*
+           * the dynamic way
+           */
+        return new TestSuite(SimpleTest.class);
+    }
+
+    public void testAdd() {
+        double result = fValue1 + fValue2;
+        // forced failure result == 5
+        assertTrue(result == 6);
+    }
+
+    public int unused;
+
+    public void testDivideByZero() {
+        int zero = 0;
+        int result = 8 / zero;
+        unused = result; // avoid warning for not using result
+    }
+
+    public void testEquals() {
+        assertEquals(12, 12);
+        assertEquals(12L, 12L);
+        assertEquals(new Long(12), new Long(12));
+
+        assertEquals("Size", 12, 13);
+        assertEquals("Capacity", 12.0, 11.99, 0.0);
+    }
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/samples/money/IMoney.java b/google3/third_party/java_src/junit/test/java/junit/samples/money/IMoney.java
new file mode 100644
index 0000000..d48757a
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/samples/money/IMoney.java
@@ -0,0 +1,51 @@
+package junit.samples.money;
+
+/**
+ * The common interface for simple Monies and MoneyBags
+ */
+public interface IMoney {
+    /**
+     * Adds a money to this money.
+     */
+    IMoney add(IMoney m);
+
+    /**
+     * Adds a simple Money to this money. This is a helper method for
+     * implementing double dispatch
+     */
+    IMoney addMoney(Money m);
+
+    /**
+     * Adds a MoneyBag to this money. This is a helper method for
+     * implementing double dispatch
+     */
+    IMoney addMoneyBag(MoneyBag s);
+
+    /**
+     * Tests whether this money is zero
+     */
+    boolean isZero();
+
+    /**
+     * Multiplies a money by the given factor.
+     */
+    IMoney multiply(int factor);
+
+    /**
+     * Negates this money.
+     */
+    IMoney negate();
+
+    /**
+     * Subtracts a money from this money.
+     */
+    IMoney subtract(IMoney m);
+
+    /**
+     * Append this to a MoneyBag m.
+     * appendTo() needs to be public because it is used
+     * polymorphically, but it should not be used by clients
+     * because it modifies the argument m.
+     */
+    void appendTo(MoneyBag m);
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/samples/money/Money.java b/google3/third_party/java_src/junit/test/java/junit/samples/money/Money.java
new file mode 100644
index 0000000..de6525b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/samples/money/Money.java
@@ -0,0 +1,92 @@
+package junit.samples.money;
+
+/**
+ * A simple Money.
+ */
+public class Money implements IMoney {
+
+    private int fAmount;
+    private String fCurrency;
+
+    /**
+     * Constructs a money from the given amount and currency.
+     */
+    public Money(int amount, String currency) {
+        fAmount = amount;
+        fCurrency = currency;
+    }
+
+    /**
+     * Adds a money to this money. Forwards the request to the addMoney helper.
+     */
+    public IMoney add(IMoney m) {
+        return m.addMoney(this);
+    }
+
+    public IMoney addMoney(Money m) {
+        if (m.currency().equals(currency())) {
+            return new Money(amount() + m.amount(), currency());
+        }
+        return MoneyBag.create(this, m);
+    }
+
+    public IMoney addMoneyBag(MoneyBag s) {
+        return s.addMoney(this);
+    }
+
+    public int amount() {
+        return fAmount;
+    }
+
+    public String currency() {
+        return fCurrency;
+    }
+
+    @Override
+    public boolean equals(Object anObject) {
+        if (isZero()) {
+            if (anObject instanceof IMoney) {
+                return ((IMoney) anObject).isZero();
+            }
+        }
+        if (anObject instanceof Money) {
+            Money aMoney = (Money) anObject;
+            return aMoney.currency().equals(currency())
+                    && amount() == aMoney.amount();
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        if (fAmount == 0) {
+            return 0;
+        }
+        return fCurrency.hashCode() + fAmount;
+    }
+
+    public boolean isZero() {
+        return amount() == 0;
+    }
+
+    public IMoney multiply(int factor) {
+        return new Money(amount() * factor, currency());
+    }
+
+    public IMoney negate() {
+        return new Money(-amount(), currency());
+    }
+
+    public IMoney subtract(IMoney m) {
+        return add(m.negate());
+    }
+
+    @Override
+    public String toString() {
+        return "[" + amount() + " " + currency() + "]";
+    }
+
+    public /*this makes no sense*/ void appendTo(MoneyBag m) {
+        m.appendMoney(this);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/samples/money/MoneyBag.java b/google3/third_party/java_src/junit/test/java/junit/samples/money/MoneyBag.java
new file mode 100644
index 0000000..e02bb51
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/samples/money/MoneyBag.java
@@ -0,0 +1,155 @@
+package junit.samples.money;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A MoneyBag defers exchange rate conversions. For example adding
+ * 12 Swiss Francs to 14 US Dollars is represented as a bag
+ * containing the two Monies 12 CHF and 14 USD. Adding another
+ * 10 Swiss francs gives a bag with 22 CHF and 14 USD. Due to
+ * the deferred exchange rate conversion we can later value a
+ * MoneyBag with different exchange rates.
+ *
+ * A MoneyBag is represented as a list of Monies and provides
+ * different constructors to create a MoneyBag.
+ */
+public class MoneyBag implements IMoney {
+    private List<Money> fMonies = new ArrayList<Money>(5);
+
+    public static IMoney create(IMoney m1, IMoney m2) {
+        MoneyBag result = new MoneyBag();
+        m1.appendTo(result);
+        m2.appendTo(result);
+        return result.simplify();
+    }
+
+    public IMoney add(IMoney m) {
+        return m.addMoneyBag(this);
+    }
+
+    public IMoney addMoney(Money m) {
+        return MoneyBag.create(m, this);
+    }
+
+    public IMoney addMoneyBag(MoneyBag s) {
+        return MoneyBag.create(s, this);
+    }
+
+    void appendBag(MoneyBag aBag) {
+        for (Money each : aBag.fMonies) {
+            appendMoney(each);
+        }
+    }
+
+    void appendMoney(Money aMoney) {
+        if (aMoney.isZero()) return;
+        IMoney old = findMoney(aMoney.currency());
+        if (old == null) {
+            fMonies.add(aMoney);
+            return;
+        }
+        fMonies.remove(old);
+        Money sum = (Money) old.add(aMoney);
+        if (sum.isZero()) {
+            return;
+        }
+        fMonies.add(sum);
+    }
+
+    @Override
+    public boolean equals(Object anObject) {
+        if (isZero()) {
+            if (anObject instanceof IMoney) {
+                return ((IMoney) anObject).isZero();
+            }
+        }
+
+        if (anObject instanceof MoneyBag) {
+            MoneyBag aMoneyBag = (MoneyBag) anObject;
+            if (aMoneyBag.fMonies.size() != fMonies.size()) {
+                return false;
+            }
+
+            for (Money each : fMonies) {
+                if (!aMoneyBag.contains(each)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    private Money findMoney(String currency) {
+        for (Money each : fMonies) {
+            if (each.currency().equals(currency)) {
+                return each;
+            }
+        }
+        return null;
+    }
+
+    private boolean contains(Money m) {
+        Money found = findMoney(m.currency());
+        if (found == null) return false;
+        return found.amount() == m.amount();
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 0;
+        for (Money each : fMonies) {
+            hash ^= each.hashCode();
+        }
+        return hash;
+    }
+
+    public boolean isZero() {
+        return fMonies.size() == 0;
+    }
+
+    public IMoney multiply(int factor) {
+        MoneyBag result = new MoneyBag();
+        if (factor != 0) {
+            for (Money each : fMonies) {
+                result.appendMoney((Money) each.multiply(factor));
+            }
+        }
+        return result;
+    }
+
+    public IMoney negate() {
+        MoneyBag result = new MoneyBag();
+        for (Money each : fMonies) {
+            result.appendMoney((Money) each.negate());
+        }
+        return result;
+    }
+
+    private IMoney simplify() {
+        if (fMonies.size() == 1) {
+            return fMonies.iterator().next();
+        }
+        return this;
+    }
+
+    public IMoney subtract(IMoney m) {
+        return add(m.negate());
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("{");
+        for (Money each : fMonies) {
+            sb.append(each);
+        }
+        sb.append("}");
+        return sb.toString();
+    }
+
+    public void appendTo(MoneyBag m) {
+        m.appendBag(this);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/samples/money/MoneyTest.java b/google3/third_party/java_src/junit/test/java/junit/samples/money/MoneyTest.java
new file mode 100644
index 0000000..170363a
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/samples/money/MoneyTest.java
@@ -0,0 +1,166 @@
+package junit.samples.money;
+
+import junit.framework.TestCase;
+
+public class MoneyTest extends TestCase {
+    private Money f12CHF;
+    private Money f14CHF;
+    private Money f7USD;
+    private Money f21USD;
+
+    private IMoney fMB1;
+    private IMoney fMB2;
+
+    public static void main(String args[]) {
+        junit.textui.TestRunner.run(MoneyTest.class);
+    }
+
+    @Override
+    protected void setUp() {
+        f12CHF = new Money(12, "CHF");
+        f14CHF = new Money(14, "CHF");
+        f7USD = new Money(7, "USD");
+        f21USD = new Money(21, "USD");
+
+        fMB1 = MoneyBag.create(f12CHF, f7USD);
+        fMB2 = MoneyBag.create(f14CHF, f21USD);
+    }
+
+    public void testBagMultiply() {
+        // {[12 CHF][7 USD]} *2 == {[24 CHF][14 USD]}
+        IMoney expected = MoneyBag.create(new Money(24, "CHF"), new Money(14, "USD"));
+        assertEquals(expected, fMB1.multiply(2));
+        assertEquals(fMB1, fMB1.multiply(1));
+        assertTrue(fMB1.multiply(0).isZero());
+    }
+
+    public void testBagNegate() {
+        // {[12 CHF][7 USD]} negate == {[-12 CHF][-7 USD]}
+        IMoney expected = MoneyBag.create(new Money(-12, "CHF"), new Money(-7, "USD"));
+        assertEquals(expected, fMB1.negate());
+    }
+
+    public void testBagSimpleAdd() {
+        // {[12 CHF][7 USD]} + [14 CHF] == {[26 CHF][7 USD]}
+        IMoney expected = MoneyBag.create(new Money(26, "CHF"), new Money(7, "USD"));
+        assertEquals(expected, fMB1.add(f14CHF));
+    }
+
+    public void testBagSubtract() {
+        // {[12 CHF][7 USD]} - {[14 CHF][21 USD] == {[-2 CHF][-14 USD]}
+        IMoney expected = MoneyBag.create(new Money(-2, "CHF"), new Money(-14, "USD"));
+        assertEquals(expected, fMB1.subtract(fMB2));
+    }
+
+    public void testBagSumAdd() {
+        // {[12 CHF][7 USD]} + {[14 CHF][21 USD]} == {[26 CHF][28 USD]}
+        IMoney expected = MoneyBag.create(new Money(26, "CHF"), new Money(28, "USD"));
+        assertEquals(expected, fMB1.add(fMB2));
+    }
+
+    public void testIsZero() {
+        assertTrue(fMB1.subtract(fMB1).isZero());
+        assertTrue(MoneyBag.create(new Money(0, "CHF"), new Money(0, "USD")).isZero());
+    }
+
+    public void testMixedSimpleAdd() {
+        // [12 CHF] + [7 USD] == {[12 CHF][7 USD]}
+        IMoney expected = MoneyBag.create(f12CHF, f7USD);
+        assertEquals(expected, f12CHF.add(f7USD));
+    }
+
+    public void testBagNotEquals() {
+        IMoney bag = MoneyBag.create(f12CHF, f7USD);
+        assertFalse(bag.equals(new Money(12, "DEM").add(f7USD)));
+    }
+
+    public void testMoneyBagEquals() {
+        assertTrue(!fMB1.equals(null));
+
+        assertEquals(fMB1, fMB1);
+        IMoney equal = MoneyBag.create(new Money(12, "CHF"), new Money(7, "USD"));
+        assertTrue(fMB1.equals(equal));
+        assertTrue(!fMB1.equals(f12CHF));
+        assertTrue(!f12CHF.equals(fMB1));
+        assertTrue(!fMB1.equals(fMB2));
+    }
+
+    public void testMoneyBagHash() {
+        IMoney equal = MoneyBag.create(new Money(12, "CHF"), new Money(7, "USD"));
+        assertEquals(fMB1.hashCode(), equal.hashCode());
+    }
+
+    public void testMoneyEquals() {
+        assertTrue(!f12CHF.equals(null));
+        Money equalMoney = new Money(12, "CHF");
+        assertEquals(f12CHF, f12CHF);
+        assertEquals(f12CHF, equalMoney);
+        assertEquals(f12CHF.hashCode(), equalMoney.hashCode());
+        assertTrue(!f12CHF.equals(f14CHF));
+    }
+
+    public void testMoneyHash() {
+        assertTrue(!f12CHF.equals(null));
+        Money equal = new Money(12, "CHF");
+        assertEquals(f12CHF.hashCode(), equal.hashCode());
+    }
+
+    public void testSimplify() {
+        IMoney money = MoneyBag.create(new Money(26, "CHF"), new Money(28, "CHF"));
+        assertEquals(new Money(54, "CHF"), money);
+    }
+
+    public void testNormalize2() {
+        // {[12 CHF][7 USD]} - [12 CHF] == [7 USD]
+        Money expected = new Money(7, "USD");
+        assertEquals(expected, fMB1.subtract(f12CHF));
+    }
+
+    public void testNormalize3() {
+        // {[12 CHF][7 USD]} - {[12 CHF][3 USD]} == [4 USD]
+        IMoney ms1 = MoneyBag.create(new Money(12, "CHF"), new Money(3, "USD"));
+        Money expected = new Money(4, "USD");
+        assertEquals(expected, fMB1.subtract(ms1));
+    }
+
+    public void testNormalize4() {
+        // [12 CHF] - {[12 CHF][3 USD]} == [-3 USD]
+        IMoney ms1 = MoneyBag.create(new Money(12, "CHF"), new Money(3, "USD"));
+        Money expected = new Money(-3, "USD");
+        assertEquals(expected, f12CHF.subtract(ms1));
+    }
+
+    public void testPrint() {
+        assertEquals("[12 CHF]", f12CHF.toString());
+    }
+
+    public void testSimpleAdd() {
+        // [12 CHF] + [14 CHF] == [26 CHF]
+        Money expected = new Money(26, "CHF");
+        assertEquals(expected, f12CHF.add(f14CHF));
+    }
+
+    public void testSimpleBagAdd() {
+        // [14 CHF] + {[12 CHF][7 USD]} == {[26 CHF][7 USD]}
+        IMoney expected = MoneyBag.create(new Money(26, "CHF"), new Money(7, "USD"));
+        assertEquals(expected, f14CHF.add(fMB1));
+    }
+
+    public void testSimpleMultiply() {
+        // [14 CHF] *2 == [28 CHF]
+        Money expected = new Money(28, "CHF");
+        assertEquals(expected, f14CHF.multiply(2));
+    }
+
+    public void testSimpleNegate() {
+        // [14 CHF] negate == [-14 CHF]
+        Money expected = new Money(-14, "CHF");
+        assertEquals(expected, f14CHF.negate());
+    }
+
+    public void testSimpleSubtract() {
+        // [14 CHF] - [12 CHF] == [2 CHF]
+        Money expected = new Money(2, "CHF");
+        assertEquals(expected, f14CHF.subtract(f12CHF));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/samples/money/package-info.java b/google3/third_party/java_src/junit/test/java/junit/samples/money/package-info.java
new file mode 100644
index 0000000..eb37dd8
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/samples/money/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Example "Money" for JUnit v3.x.
+ */
+package junit.samples.money;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/samples/package-info.java b/google3/third_party/java_src/junit/test/java/junit/samples/package-info.java
new file mode 100644
index 0000000..7b9ea8f
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/samples/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * JUnit v3.x examples.
+ */
+package junit.samples;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/AllTests.java b/google3/third_party/java_src/junit/test/java/junit/tests/AllTests.java
new file mode 100644
index 0000000..8be6e26
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/AllTests.java
@@ -0,0 +1,22 @@
+package junit.tests;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * TestSuite that runs all the JUnit tests
+ */
+public class AllTests {
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite("Framework Tests");
+        suite.addTest(junit.tests.framework.AllTests.suite());
+        suite.addTest(junit.tests.runner.AllTests.suite());
+        suite.addTest(junit.tests.extensions.AllTests.suite());
+        return suite;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/SampleJUnit3Tests.java b/google3/third_party/java_src/junit/test/java/junit/tests/SampleJUnit3Tests.java
new file mode 100644
index 0000000..46f996b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/SampleJUnit3Tests.java
@@ -0,0 +1,51 @@
+package junit.tests;
+
+import junit.framework.TestCase;
+
+/**
+ * Container for sample JUnit3-style tests used in integration tests.
+ */
+public class SampleJUnit3Tests {
+
+    public static class TestWithOneThrowingTestMethod extends TestCase {
+
+        public void testAlwaysThrows() {
+            new FakeClassUnderTest().throwsExceptionWithoutCause();
+        }
+    }
+
+    public static class TestWithThrowingSetUpMethod extends TestCase {
+
+        @Override
+        protected void setUp() throws Exception {
+            super.setUp();
+            new FakeClassUnderTest().throwsExceptionWithoutCause();
+        }
+
+        public void testAlwaysPasses() {
+        }
+    }
+
+    private static class FakeClassUnderTest {
+
+        public void throwsExceptionWithCause() {
+            doThrowExceptionWithCause();
+        }
+
+        public void throwsExceptionWithoutCause() {
+            doThrowExceptionWithoutCause();
+        }
+
+        private void doThrowExceptionWithCause() {
+            try {
+                throwsExceptionWithoutCause();
+            } catch (Exception e) {
+                throw new RuntimeException("outer", e);
+            }
+        }
+
+        private void doThrowExceptionWithoutCause() {
+            throw new RuntimeException("cause");
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/WasRun.java b/google3/third_party/java_src/junit/test/java/junit/tests/WasRun.java
new file mode 100644
index 0000000..fb294ca
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/WasRun.java
@@ -0,0 +1,16 @@
+package junit.tests;
+
+import junit.framework.TestCase;
+
+/**
+ * A helper test case for testing whether the testing method
+ * is run.
+ */
+public class WasRun extends TestCase {
+    public boolean fWasRun = false;
+
+    @Override
+    protected void runTest() {
+        fWasRun = true;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/extensions/ActiveTestTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/extensions/ActiveTestTest.java
new file mode 100644
index 0000000..5015b76
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/extensions/ActiveTestTest.java
@@ -0,0 +1,64 @@
+package junit.tests.extensions;
+
+import junit.extensions.ActiveTestSuite;
+import junit.extensions.RepeatedTest;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+
+/**
+ * Testing the ActiveTest support
+ */
+public class ActiveTestTest extends TestCase {
+
+    public static class SuccessTest extends TestCase {
+        @Override
+        public void runTest() {
+        }
+    }
+
+    public void testActiveTest() {
+        Test test = createActiveTestSuite();
+        TestResult result = new TestResult();
+        test.run(result);
+        assertEquals(100, result.runCount());
+        assertEquals(0, result.failureCount());
+        assertEquals(0, result.errorCount());
+    }
+
+    public void testActiveRepeatedTest() {
+        Test test = new RepeatedTest(createActiveTestSuite(), 5);
+        TestResult result = new TestResult();
+        test.run(result);
+        assertEquals(500, result.runCount());
+        assertEquals(0, result.failureCount());
+        assertEquals(0, result.errorCount());
+    }
+
+    public void testActiveRepeatedTest0() {
+        Test test = new RepeatedTest(createActiveTestSuite(), 0);
+        TestResult result = new TestResult();
+        test.run(result);
+        assertEquals(0, result.runCount());
+        assertEquals(0, result.failureCount());
+        assertEquals(0, result.errorCount());
+    }
+
+    public void testActiveRepeatedTest1() {
+        Test test = new RepeatedTest(createActiveTestSuite(), 1);
+        TestResult result = new TestResult();
+        test.run(result);
+        assertEquals(100, result.runCount());
+        assertEquals(0, result.failureCount());
+        assertEquals(0, result.errorCount());
+    }
+
+    ActiveTestSuite createActiveTestSuite() {
+        ActiveTestSuite suite = new ActiveTestSuite();
+        for (int i = 0; i < 100; i++) {
+            suite.addTest(new SuccessTest());
+        }
+        return suite;
+    }
+
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/extensions/AllTests.java b/google3/third_party/java_src/junit/test/java/junit/tests/extensions/AllTests.java
new file mode 100644
index 0000000..1cbcfa5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/extensions/AllTests.java
@@ -0,0 +1,22 @@
+package junit.tests.extensions;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * TestSuite that runs all the extension tests
+ */
+public class AllTests {
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+    public static Test suite() { // Collect tests manually because we have to test class collection code
+        TestSuite suite = new TestSuite("Framework Tests");
+        suite.addTestSuite(ExtensionTest.class);
+        suite.addTestSuite(ActiveTestTest.class);
+        suite.addTestSuite(RepeatedTestTest.class);
+        return suite;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/extensions/ExtensionTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/extensions/ExtensionTest.java
new file mode 100644
index 0000000..155a478
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/extensions/ExtensionTest.java
@@ -0,0 +1,104 @@
+package junit.tests.extensions;
+
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+import junit.tests.WasRun;
+
+/**
+ * A test case testing the extensions to the testing framework.
+ */
+public class ExtensionTest extends TestCase {
+    static class TornDown extends TestSetup {
+        boolean fTornDown = false;
+
+        TornDown(Test test) {
+            super(test);
+        }
+
+        @Override
+        protected void tearDown() {
+            fTornDown = true;
+        }
+    }
+
+    public void testRunningErrorInTestSetup() {
+        TestCase test = new TestCase("failure") {
+            @Override
+            public void runTest() {
+                fail();
+            }
+        };
+
+        TestSetup wrapper = new TestSetup(test);
+
+        TestResult result = new TestResult();
+        wrapper.run(result);
+        assertTrue(!result.wasSuccessful());
+    }
+
+    public void testRunningErrorsInTestSetup() {
+        TestCase failure = new TestCase("failure") {
+            @Override
+            public void runTest() {
+                fail();
+            }
+        };
+
+        TestCase error = new TestCase("error") {
+            @Override
+            public void runTest() {
+                throw new Error();
+            }
+        };
+
+        TestSuite suite = new TestSuite();
+        suite.addTest(failure);
+        suite.addTest(error);
+
+        TestSetup wrapper = new TestSetup(suite);
+
+        TestResult result = new TestResult();
+        wrapper.run(result);
+
+        assertEquals(1, result.failureCount());
+        assertEquals(1, result.errorCount());
+    }
+
+    public void testSetupErrorDontTearDown() {
+        WasRun test = new WasRun();
+
+        TornDown wrapper = new TornDown(test) {
+            @SuppressWarnings("deprecation")
+            @Override
+            public void setUp() {
+                fail();
+            }
+        };
+
+        TestResult result = new TestResult();
+        wrapper.run(result);
+
+        assertTrue(!wrapper.fTornDown);
+    }
+
+    public void testSetupErrorInTestSetup() {
+        WasRun test = new WasRun();
+
+        TestSetup wrapper = new TestSetup(test) {
+            @SuppressWarnings("deprecation")
+            @Override
+            public void setUp() {
+                fail();
+            }
+        };
+
+        TestResult result = new TestResult();
+        wrapper.run(result);
+
+        assertTrue(!test.fWasRun);
+        assertTrue(!result.wasSuccessful());
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/extensions/RepeatedTestTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/extensions/RepeatedTestTest.java
new file mode 100644
index 0000000..0ba7366
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/extensions/RepeatedTestTest.java
@@ -0,0 +1,62 @@
+package junit.tests.extensions;
+
+import junit.extensions.RepeatedTest;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+
+/**
+ * Testing the RepeatedTest support.
+ */
+public class RepeatedTestTest extends TestCase {
+    private TestSuite fSuite;
+
+    public static class SuccessTest extends TestCase {
+
+        @Override
+        public void runTest() {
+        }
+    }
+
+    public RepeatedTestTest(String name) {
+        super(name);
+        fSuite = new TestSuite();
+        fSuite.addTest(new SuccessTest());
+        fSuite.addTest(new SuccessTest());
+    }
+
+    public void testRepeatedOnce() {
+        Test test = new RepeatedTest(fSuite, 1);
+        assertEquals(2, test.countTestCases());
+        TestResult result = new TestResult();
+        test.run(result);
+        assertEquals(2, result.runCount());
+    }
+
+    public void testRepeatedMoreThanOnce() {
+        Test test = new RepeatedTest(fSuite, 3);
+        assertEquals(6, test.countTestCases());
+        TestResult result = new TestResult();
+        test.run(result);
+        assertEquals(6, result.runCount());
+    }
+
+    public void testRepeatedZero() {
+        Test test = new RepeatedTest(fSuite, 0);
+        assertEquals(0, test.countTestCases());
+        TestResult result = new TestResult();
+        test.run(result);
+        assertEquals(0, result.runCount());
+    }
+
+    public void testRepeatedNegative() {
+        try {
+            new RepeatedTest(fSuite, -1);
+        } catch (IllegalArgumentException e) {
+            assertTrue(e.getMessage().contains(">="));
+            return;
+        }
+        fail("Should throw an IllegalArgumentException");
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/extensions/package-info.java b/google3/third_party/java_src/junit/test/java/junit/tests/extensions/package-info.java
new file mode 100644
index 0000000..acc0194
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/extensions/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Tests for the JUnit v3.x extension functionality.
+ */
+package junit.tests.extensions;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/AllTests.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/AllTests.java
new file mode 100644
index 0000000..860ddca
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/AllTests.java
@@ -0,0 +1,31 @@
+package junit.tests.framework;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * TestSuite that runs all the sample tests
+ */
+public class AllTests {
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite("Framework Tests");
+        suite.addTestSuite(TestCaseTest.class);
+        suite.addTest(SuiteTest.suite()); // Tests suite building, so can't use automatic test extraction
+        suite.addTestSuite(TestListenerTest.class);
+        suite.addTestSuite(AssertionFailedErrorTest.class);
+        suite.addTestSuite(AssertTest.class);
+        suite.addTestSuite(TestImplementorTest.class);
+        suite.addTestSuite(NoArgTestCaseTest.class);
+        suite.addTestSuite(ComparisonCompactorTest.class);
+        suite.addTestSuite(ComparisonFailureTest.class);
+        suite.addTestSuite(DoublePrecisionAssertTest.class);
+        suite.addTestSuite(FloatAssertTest.class);
+        return suite;
+    }
+
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/AssertTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/AssertTest.java
new file mode 100644
index 0000000..19cca63
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/AssertTest.java
@@ -0,0 +1,171 @@
+package junit.tests.framework;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.ComparisonFailure;
+import junit.framework.TestCase;
+
+public class AssertTest extends TestCase {
+
+    /* In the tests that follow, we can't use standard formatting
+      * for exception tests:
+      *     try {
+      *         somethingThatShouldThrow();
+      *         fail();
+      *     catch (AssertionFailedError e) {
+      *     }
+      * because fail() would never be reported.
+      */
+    public void testFail() {
+        // Also, we are testing fail, so we can't rely on fail() working.
+        // We have to throw the exception manually.
+        try {
+            fail();
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        throw new AssertionFailedError();
+    }
+
+    public void testAssertionFailedErrorToStringWithNoMessage() {
+        // Also, we are testing fail, so we can't rely on fail() working.
+        // We have to throw the exception manually.
+        try {
+            fail();
+        } catch (AssertionFailedError e) {
+            assertEquals("junit.framework.AssertionFailedError", e.toString());
+            return;
+        }
+        throw new AssertionFailedError();
+    }
+
+    public void testAssertionFailedErrorToStringWithMessage() {
+        // Also, we are testing fail, so we can't rely on fail() working.
+        // We have to throw the exception manually.
+        try {
+            fail("woops!");
+        } catch (AssertionFailedError e) {
+            assertEquals("junit.framework.AssertionFailedError: woops!", e.toString());
+            return;
+        }
+        throw new AssertionFailedError();
+    }
+
+    public void testAssertEquals() {
+        Object o = new Object();
+        assertEquals(o, o);
+        try {
+            assertEquals(new Object(), new Object());
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertEqualsNull() {
+        assertEquals((Object) null, (Object) null);
+    }
+
+    public void testAssertStringEquals() {
+        assertEquals("a", "a");
+    }
+
+    public void testAssertNullNotEqualsString() {
+        try {
+            assertEquals(null, "foo");
+            fail();
+        } catch (ComparisonFailure e) {
+        }
+    }
+
+    public void testAssertStringNotEqualsNull() {
+        try {
+            assertEquals("foo", null);
+            fail();
+        } catch (ComparisonFailure e) {
+            e.getMessage(); // why no assertion?
+        }
+    }
+
+    public void testAssertNullNotEqualsNull() {
+        try {
+            assertEquals(null, new Object());
+        } catch (AssertionFailedError e) {
+            e.getMessage(); // why no assertion?
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertNull() {
+        assertNull(null);
+        try {
+            assertNull(new Object());
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertNotNull() {
+        assertNotNull(new Object());
+        try {
+            assertNotNull(null);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertTrue() {
+        assertTrue(true);
+        try {
+            assertTrue(false);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertFalse() {
+        assertFalse(false);
+        try {
+            assertFalse(true);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertSame() {
+        Object o = new Object();
+        assertSame(o, o);
+        try {
+            assertSame(new Integer(1), new Integer(1));
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertNotSame() {
+        assertNotSame(new Integer(1), null);
+        assertNotSame(null, new Integer(1));
+        assertNotSame(new Integer(1), new Integer(1));
+        try {
+            Integer obj = new Integer(1);
+            assertNotSame(obj, obj);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertNotSameFailsNull() {
+        try {
+            assertNotSame(null, null);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/AssertionFailedErrorTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/AssertionFailedErrorTest.java
new file mode 100644
index 0000000..16328b4
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/AssertionFailedErrorTest.java
@@ -0,0 +1,23 @@
+package junit.tests.framework;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
+
+public class AssertionFailedErrorTest extends TestCase {
+    private static final String ARBITRARY_MESSAGE = "arbitrary message";
+
+    public void testCreateErrorWithoutMessage() throws Exception {
+        AssertionFailedError error = new AssertionFailedError();
+        assertNull(error.getMessage());
+    }
+
+    public void testCreateErrorWithMessage() throws Exception {
+        AssertionFailedError error = new AssertionFailedError(ARBITRARY_MESSAGE);
+        assertEquals(ARBITRARY_MESSAGE, error.getMessage());
+    }
+
+    public void testCreateErrorWithoutMessageInsteadOfNull() throws Exception {
+        AssertionFailedError error = new AssertionFailedError(null);
+        assertEquals("", error.getMessage());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/ComparisonCompactorTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/ComparisonCompactorTest.java
new file mode 100644
index 0000000..16e0b4e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/ComparisonCompactorTest.java
@@ -0,0 +1,102 @@
+package junit.tests.framework;
+
+import junit.framework.ComparisonCompactor;
+import junit.framework.TestCase;
+
+public class ComparisonCompactorTest extends TestCase {
+
+    public void testMessage() {
+        String failure = new ComparisonCompactor(0, "b", "c").compact("a");
+        assertTrue("a expected:<[b]> but was:<[c]>".equals(failure));
+    }
+
+    public void testStartSame() {
+        String failure = new ComparisonCompactor(1, "ba", "bc").compact(null);
+        assertEquals("expected:<b[a]> but was:<b[c]>", failure);
+    }
+
+    public void testEndSame() {
+        String failure = new ComparisonCompactor(1, "ab", "cb").compact(null);
+        assertEquals("expected:<[a]b> but was:<[c]b>", failure);
+    }
+
+    public void testSame() {
+        String failure = new ComparisonCompactor(1, "ab", "ab").compact(null);
+        assertEquals("expected:<ab> but was:<ab>", failure);
+    }
+
+    public void testNoContextStartAndEndSame() {
+        String failure = new ComparisonCompactor(0, "abc", "adc").compact(null);
+        assertEquals("expected:<...[b]...> but was:<...[d]...>", failure);
+    }
+
+    public void testStartAndEndContext() {
+        String failure = new ComparisonCompactor(1, "abc", "adc").compact(null);
+        assertEquals("expected:<a[b]c> but was:<a[d]c>", failure);
+    }
+
+    public void testStartAndEndContextWithEllipses() {
+        String failure = new ComparisonCompactor(1, "abcde", "abfde").compact(null);
+        assertEquals("expected:<...b[c]d...> but was:<...b[f]d...>", failure);
+    }
+
+    public void testComparisonErrorStartSameComplete() {
+        String failure = new ComparisonCompactor(2, "ab", "abc").compact(null);
+        assertEquals("expected:<ab[]> but was:<ab[c]>", failure);
+    }
+
+    public void testComparisonErrorEndSameComplete() {
+        String failure = new ComparisonCompactor(0, "bc", "abc").compact(null);
+        assertEquals("expected:<[]...> but was:<[a]...>", failure);
+    }
+
+    public void testComparisonErrorEndSameCompleteContext() {
+        String failure = new ComparisonCompactor(2, "bc", "abc").compact(null);
+        assertEquals("expected:<[]bc> but was:<[a]bc>", failure);
+    }
+
+    public void testComparisonErrorOverlappingMatches() {
+        String failure = new ComparisonCompactor(0, "abc", "abbc").compact(null);
+        assertEquals("expected:<...[]...> but was:<...[b]...>", failure);
+    }
+
+    public void testComparisonErrorOverlappingMatchesContext() {
+        String failure = new ComparisonCompactor(2, "abc", "abbc").compact(null);
+        assertEquals("expected:<ab[]c> but was:<ab[b]c>", failure);
+    }
+
+    public void testComparisonErrorOverlappingMatches2() {
+        String failure = new ComparisonCompactor(0, "abcdde", "abcde").compact(null);
+        assertEquals("expected:<...[d]...> but was:<...[]...>", failure);
+    }
+
+    public void testComparisonErrorOverlappingMatches2Context() {
+        String failure = new ComparisonCompactor(2, "abcdde", "abcde").compact(null);
+        assertEquals("expected:<...cd[d]e> but was:<...cd[]e>", failure);
+    }
+
+    public void testComparisonErrorWithActualNull() {
+        String failure = new ComparisonCompactor(0, "a", null).compact(null);
+        assertEquals("expected:<a> but was:<null>", failure);
+    }
+
+    public void testComparisonErrorWithActualNullContext() {
+        String failure = new ComparisonCompactor(2, "a", null).compact(null);
+        assertEquals("expected:<a> but was:<null>", failure);
+    }
+
+    public void testComparisonErrorWithExpectedNull() {
+        String failure = new ComparisonCompactor(0, null, "a").compact(null);
+        assertEquals("expected:<null> but was:<a>", failure);
+    }
+
+    public void testComparisonErrorWithExpectedNullContext() {
+        String failure = new ComparisonCompactor(2, null, "a").compact(null);
+        assertEquals("expected:<null> but was:<a>", failure);
+    }
+
+    public void testBug609972() {
+        String failure = new ComparisonCompactor(10, "S&P500", "0").compact(null);
+        assertEquals("expected:<[S&P50]0> but was:<[]0>", failure);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/ComparisonFailureTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/ComparisonFailureTest.java
new file mode 100644
index 0000000..284b7f5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/ComparisonFailureTest.java
@@ -0,0 +1,47 @@
+package junit.tests.framework;
+
+import junit.framework.ComparisonFailure;
+import junit.framework.TestCase;
+
+public class ComparisonFailureTest extends TestCase {
+
+    // Most of the tests are in ComparisonCompactorTest
+    public void testConnection() {
+        ComparisonFailure failure = new ComparisonFailure("warning", "Mary had a little lamb", "Mary had the little lamb");
+        assertEquals("warning expected:<Mary had [a] little lamb> but was:<Mary had [the] little lamb>", failure.getMessage());
+    }
+
+    // This is like an instanceof test.
+    public void testThrowing() {
+        try {
+            assertEquals("a", "b");
+        } catch (ComparisonFailure e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testExceptionToStringWithMessage() {
+        try {
+            assertEquals("woops!", "a", "b");
+        } catch (ComparisonFailure e) {
+            if (!e.toString().startsWith("junit.framework.ComparisonFailure: woops! expected:<")) {
+                fail("Unexpected message: " + e);
+            }
+            return;
+        }
+        fail();
+    }
+
+    public void testExceptionToStringWithoutMessage() {
+        try {
+            assertEquals("a", "b");
+        } catch (ComparisonFailure e) {
+            if (!e.toString().startsWith("junit.framework.ComparisonFailure: expected:<")) {
+                fail("Unexpected message: " + e);
+            }
+            return;
+        }
+        fail();
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/DoublePrecisionAssertTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/DoublePrecisionAssertTest.java
new file mode 100644
index 0000000..f416109
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/DoublePrecisionAssertTest.java
@@ -0,0 +1,59 @@
+package junit.tests.framework;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
+
+public class DoublePrecisionAssertTest extends TestCase {
+
+    /**
+     * Test for the special Double.NaN value.
+     */
+    public void testAssertEqualsNaNFails() {
+        try {
+            assertEquals(1.234, Double.NaN, 0.0);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertNaNEqualsFails() {
+        try {
+            assertEquals(Double.NaN, 1.234, 0.0);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertNaNEqualsNaN() {
+        assertEquals(Double.NaN, Double.NaN, 0.0);
+    }
+
+    public void testAssertPosInfinityNotEqualsNegInfinity() {
+        try {
+            assertEquals(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, 0.0);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertPosInfinityNotEquals() {
+        try {
+            assertEquals(Double.POSITIVE_INFINITY, 1.23, 0.0);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertPosInfinityEqualsInfinity() {
+        assertEquals(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 0.0);
+    }
+
+    public void testAssertNegInfinityEqualsInfinity() {
+        assertEquals(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 0.0);
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/Failure.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/Failure.java
new file mode 100644
index 0000000..00267df
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/Failure.java
@@ -0,0 +1,13 @@
+package junit.tests.framework;
+
+import junit.framework.TestCase;
+
+/**
+ * A test case testing the testing framework.
+ */
+public class Failure extends TestCase {
+    @Override
+    public void runTest() {
+        fail();
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/FloatAssertTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/FloatAssertTest.java
new file mode 100644
index 0000000..aeae944
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/FloatAssertTest.java
@@ -0,0 +1,63 @@
+package junit.tests.framework;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
+
+public class FloatAssertTest extends TestCase {
+
+    /**
+     * Test for the special Double.NaN value.
+     */
+    public void testAssertEqualsNaNFails() {
+        try {
+            assertEquals(1.234f, Float.NaN, 0.0);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertNaNEqualsFails() {
+        try {
+            assertEquals(Float.NaN, 1.234f, 0.0);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertNaNEqualsNaN() {
+        assertEquals(Float.NaN, Float.NaN, 0.0);
+    }
+
+    public void testAssertPosInfinityNotEqualsNegInfinity() {
+        try {
+            assertEquals(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, 0.0);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertPosInfinityNotEquals() {
+        try {
+            assertEquals(Float.POSITIVE_INFINITY, 1.23f, 0.0);
+        } catch (AssertionFailedError e) {
+            return;
+        }
+        fail();
+    }
+
+    public void testAssertPosInfinityEqualsInfinity() {
+        assertEquals(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, 0.0);
+    }
+
+    public void testAssertNegInfinityEqualsInfinity() {
+        assertEquals(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY, 0.0);
+    }
+
+    public void testAllInfinities() {
+        assertEquals(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY);
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/InheritedTestCase.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/InheritedTestCase.java
new file mode 100644
index 0000000..f264e4e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/InheritedTestCase.java
@@ -0,0 +1,9 @@
+package junit.tests.framework;
+
+/**
+ * Test class used in SuiteTest
+ */
+public class InheritedTestCase extends OneTestCase {
+    public void test2() {
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/NoArgTestCaseTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/NoArgTestCaseTest.java
new file mode 100644
index 0000000..65d1bb5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/NoArgTestCaseTest.java
@@ -0,0 +1,8 @@
+package junit.tests.framework;
+
+import junit.framework.TestCase;
+
+public class NoArgTestCaseTest extends TestCase {
+    public void testNothing() { // If this compiles, the no arg ctor is there
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/NoTestCaseClass.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/NoTestCaseClass.java
new file mode 100644
index 0000000..f92adef
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/NoTestCaseClass.java
@@ -0,0 +1,9 @@
+package junit.tests.framework;
+
+/**
+ * Test class used in SuiteTest
+ */
+public class NoTestCaseClass extends Object {
+    public void testSuccess() {
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/NoTestCases.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/NoTestCases.java
new file mode 100644
index 0000000..61abfd3
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/NoTestCases.java
@@ -0,0 +1,11 @@
+package junit.tests.framework;
+
+import junit.framework.TestCase;
+
+/**
+ * Test class used in SuiteTest
+ */
+public class NoTestCases extends TestCase {
+    public void noTestCase() {
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/NotPublicTestCase.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/NotPublicTestCase.java
new file mode 100644
index 0000000..d95aa91
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/NotPublicTestCase.java
@@ -0,0 +1,14 @@
+package junit.tests.framework;
+
+import junit.framework.TestCase;
+
+/**
+ * Test class used in SuiteTest
+ */
+public class NotPublicTestCase extends TestCase {
+    protected void testNotPublic() {
+    }
+
+    public void testPublic() {
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/NotVoidTestCase.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/NotVoidTestCase.java
new file mode 100644
index 0000000..e087a22
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/NotVoidTestCase.java
@@ -0,0 +1,15 @@
+package junit.tests.framework;
+
+import junit.framework.TestCase;
+
+/**
+ * Test class used in SuiteTest
+ */
+public class NotVoidTestCase extends TestCase {
+    public int testNotVoid() {
+        return 1;
+    }
+
+    public void testVoid() {
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/OneTestCase.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/OneTestCase.java
new file mode 100644
index 0000000..b54b7f5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/OneTestCase.java
@@ -0,0 +1,17 @@
+package junit.tests.framework;
+
+import junit.framework.TestCase;
+
+/**
+ * Test class used in SuiteTest
+ */
+public class OneTestCase extends TestCase {
+    public void noTestCase() {
+    }
+
+    public void testCase() {
+    }
+
+    public void testCase(int arg) {
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/OverrideTestCase.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/OverrideTestCase.java
new file mode 100644
index 0000000..a9b665d
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/OverrideTestCase.java
@@ -0,0 +1,10 @@
+package junit.tests.framework;
+
+/**
+ * Test class used in SuiteTest
+ */
+public class OverrideTestCase extends OneTestCase {
+    @Override
+    public void testCase() {
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/Success.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/Success.java
new file mode 100644
index 0000000..510468f
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/Success.java
@@ -0,0 +1,16 @@
+package junit.tests.framework;
+
+import junit.framework.TestCase;
+
+/**
+ * A test case testing the testing framework.
+ */
+public class Success extends TestCase {
+
+    @Override
+    public void runTest() {
+    }
+
+    public void testSuccess() {
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/SuiteTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/SuiteTest.java
new file mode 100644
index 0000000..9854548
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/SuiteTest.java
@@ -0,0 +1,118 @@
+package junit.tests.framework;
+
+import java.util.Collections;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+
+/**
+ * A fixture for testing the "auto" test suite feature.
+ */
+public class SuiteTest extends TestCase {
+    protected TestResult fResult;
+
+    public SuiteTest(String name) {
+        super(name);
+    }
+
+    @Override
+    protected void setUp() {
+        fResult = new TestResult();
+    }
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite("Suite Tests");
+        // build the suite manually, because some of the suites are testing
+        // the functionality that automatically builds suites
+        suite.addTest(new SuiteTest("testNoTestCases"));
+        suite.addTest(new SuiteTest("testOneTestCase"));
+        suite.addTest(new SuiteTest("testNotPublicTestCase"));
+        suite.addTest(new SuiteTest("testNotVoidTestCase"));
+        suite.addTest(new SuiteTest("testNotExistingTestCase"));
+        suite.addTest(new SuiteTest("testInheritedTests"));
+        suite.addTest(new SuiteTest("testOneTestCaseEclipseSeesSameStructureAs381"));
+        suite.addTest(new SuiteTest("testNoTestCaseClass"));
+        suite.addTest(new SuiteTest("testShadowedTests"));
+        suite.addTest(new SuiteTest("testAddTestSuite"));
+        suite.addTest(new SuiteTest("testCreateSuiteFromArray"));
+
+        return suite;
+    }
+
+    public void testInheritedTests() {
+        TestSuite suite = new TestSuite(InheritedTestCase.class);
+        suite.run(fResult);
+        assertTrue(fResult.wasSuccessful());
+        assertEquals(2, fResult.runCount());
+    }
+
+    public void testNoTestCaseClass() {
+        Test t = new TestSuite(NoTestCaseClass.class);
+        t.run(fResult);
+        assertEquals(1, fResult.runCount());  // warning test
+        assertTrue(!fResult.wasSuccessful());
+    }
+
+    public void testNoTestCases() {
+        Test t = new TestSuite(NoTestCases.class);
+        t.run(fResult);
+        assertTrue(fResult.runCount() == 1);  // warning test
+        assertTrue(fResult.failureCount() == 1);
+        assertTrue(!fResult.wasSuccessful());
+    }
+
+    public void testNotExistingTestCase() {
+        Test t = new SuiteTest("notExistingMethod");
+        t.run(fResult);
+        assertTrue(fResult.runCount() == 1);
+        assertTrue(fResult.failureCount() == 1);
+        assertTrue(fResult.errorCount() == 0);
+    }
+
+    public void testNotPublicTestCase() {
+        TestSuite suite = new TestSuite(NotPublicTestCase.class);
+        // 1 public test case + 1 warning for the non-public test case
+        assertEquals(2, suite.countTestCases());
+    }
+
+    public void testNotVoidTestCase() {
+        TestSuite suite = new TestSuite(NotVoidTestCase.class);
+        assertTrue(suite.countTestCases() == 1);
+    }
+
+    public void testOneTestCase() {
+        TestSuite t = new TestSuite(OneTestCase.class);
+        t.run(fResult);
+        assertTrue(fResult.runCount() == 1);
+        assertTrue(fResult.failureCount() == 0);
+        assertTrue(fResult.errorCount() == 0);
+        assertTrue(fResult.wasSuccessful());
+    }
+
+    public void testOneTestCaseEclipseSeesSameStructureAs381() {
+        TestSuite t = new TestSuite(ThreeTestCases.class);
+        assertEquals(3, Collections.list(t.tests()).size());
+    }
+
+    public void testShadowedTests() {
+        TestSuite suite = new TestSuite(OverrideTestCase.class);
+        suite.run(fResult);
+        assertEquals(1, fResult.runCount());
+    }
+
+    public void testAddTestSuite() {
+        TestSuite suite = new TestSuite();
+        suite.addTestSuite(OneTestCase.class);
+        suite.run(fResult);
+        assertEquals(1, fResult.runCount());
+    }
+
+    public void testCreateSuiteFromArray() {
+        TestSuite suite = new TestSuite(OneTestCase.class, DoublePrecisionAssertTest.class);
+        assertEquals(2, suite.testCount());
+        assertEquals("junit.tests.framework.DoublePrecisionAssertTest", ((TestSuite) suite.testAt(1)).getName());
+        assertEquals("junit.tests.framework.OneTestCase", ((TestSuite) suite.testAt(0)).getName());
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/TestCaseTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/TestCaseTest.java
new file mode 100644
index 0000000..5c10052
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/TestCaseTest.java
@@ -0,0 +1,205 @@
+package junit.tests.framework;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestFailure;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+import junit.tests.WasRun;
+
+/**
+ * A test case testing the testing framework.
+ */
+public class TestCaseTest extends TestCase {
+
+    static class TornDown extends TestCase {
+        boolean fTornDown = false;
+
+        @Override
+        protected void tearDown() {
+            fTornDown = true;
+        }
+
+        @Override
+        protected void runTest() {
+            throw new Error("running");
+        }
+    }
+
+    public void testCaseToString() {
+        // This test wins the award for twisted snake tail eating while
+        // writing self tests. And you thought those weird anonymous
+        // inner classes were bad...
+        assertEquals("testCaseToString(junit.tests.framework.TestCaseTest)", toString());
+    }
+
+    public void testError() {
+        TestCase error = new TestCase("error") {
+            @Override
+            protected void runTest() {
+                throw new Error();
+            }
+        };
+        verifyError(error);
+    }
+
+    public void testRunAndTearDownFails() {
+        TornDown fails = new TornDown() {
+            @Override
+            protected void tearDown() {
+                super.tearDown();
+                throw new Error();
+            }
+
+            @Override
+            protected void runTest() {
+                throw new Error();
+            }
+        };
+        verifyError(fails);
+        assertTrue(fails.fTornDown);
+    }
+
+    public void testSetupFails() {
+        TestCase fails = new TestCase("success") {
+            @Override
+            protected void setUp() {
+                throw new Error();
+            }
+
+            @Override
+            protected void runTest() {
+            }
+        };
+        verifyError(fails);
+    }
+
+    public void testSuccess() {
+        TestCase success = new TestCase("success") {
+            @Override
+            protected void runTest() {
+            }
+        };
+        verifySuccess(success);
+    }
+
+    public void testFailure() {
+        TestCase failure = new TestCase("failure") {
+            @Override
+            protected void runTest() {
+                fail();
+            }
+        };
+        verifyFailure(failure);
+    }
+
+    public void testTearDownAfterError() {
+        TornDown fails = new TornDown();
+        verifyError(fails);
+        assertTrue(fails.fTornDown);
+    }
+
+    public void testTearDownFails() {
+        TestCase fails = new TestCase("success") {
+            @Override
+            protected void tearDown() {
+                throw new Error();
+            }
+
+            @Override
+            protected void runTest() {
+            }
+        };
+        verifyError(fails);
+    }
+
+    public void testTearDownSetupFails() {
+        TornDown fails = new TornDown() {
+            @Override
+            protected void setUp() {
+                throw new Error();
+            }
+        };
+        verifyError(fails);
+        assertTrue(!fails.fTornDown);
+    }
+
+    public void testWasRun() {
+        WasRun test = new WasRun();
+        test.run();
+        assertTrue(test.fWasRun);
+    }
+
+    public void testExceptionRunningAndTearDown() {
+        // With 1.4, we should
+        // wrap the exception thrown while running with the exception thrown
+        // while tearing down
+        Test t = new TornDown() {
+            @Override
+            public void tearDown() {
+                throw new Error("tearingDown");
+            }
+        };
+        TestResult result = new TestResult();
+        t.run(result);
+        TestFailure failure = result.errors().nextElement();
+        assertEquals("running", failure.thrownException().getMessage());
+    }
+
+    public void testErrorTearingDownDoesntMaskErrorRunning() {
+        final Exception running = new Exception("Running");
+        TestCase t = new TestCase() {
+            @Override
+            protected void runTest() throws Throwable {
+                throw running;
+            }
+
+            @Override
+            protected void tearDown() throws Exception {
+                throw new Error("Tearing down");
+            }
+        };
+        try {
+            t.runBare();
+        } catch (Throwable thrown) {
+            assertSame(running, thrown);
+        }
+    }
+
+    public void testNoArgTestCasePasses() {
+        Test t = new TestSuite(NoArgTestCaseTest.class);
+        TestResult result = new TestResult();
+        t.run(result);
+        assertTrue(result.runCount() == 1);
+        assertTrue(result.failureCount() == 0);
+        assertTrue(result.errorCount() == 0);
+    }
+
+    public void testNamelessTestCase() {
+        TestCase t = new TestCase() {
+        };
+        TestResult result = t.run();
+        assertEquals(1, result.failureCount());
+    }
+
+    void verifyError(TestCase test) {
+        TestResult result = test.run();
+        assertTrue(result.runCount() == 1);
+        assertTrue(result.failureCount() == 0);
+        assertTrue(result.errorCount() == 1);
+    }
+
+    void verifyFailure(TestCase test) {
+        TestResult result = test.run();
+        assertTrue(result.runCount() == 1);
+        assertTrue(result.failureCount() == 1);
+        assertTrue(result.errorCount() == 0);
+    }
+
+    void verifySuccess(TestCase test) {
+        TestResult result = test.run();
+        assertTrue(result.runCount() == 1);
+        assertTrue(result.failureCount() == 0);
+        assertTrue(result.errorCount() == 0);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/TestImplementorTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/TestImplementorTest.java
new file mode 100644
index 0000000..73ec5f8
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/TestImplementorTest.java
@@ -0,0 +1,54 @@
+package junit.tests.framework;
+
+import junit.framework.Protectable;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+
+/**
+ * Test an implementor of junit.framework.Test other than TestCase or TestSuite
+ */
+public class TestImplementorTest extends TestCase {
+    public static class DoubleTestCase implements Test {
+        private TestCase fTestCase;
+
+        public DoubleTestCase(TestCase testCase) {
+            fTestCase = testCase;
+        }
+
+        public int countTestCases() {
+            return 2;
+        }
+
+        public void run(TestResult result) {
+            result.startTest(this);
+            Protectable p = new Protectable() {
+                public void protect() throws Throwable {
+                    fTestCase.runBare();
+                    fTestCase.runBare();
+                }
+            };
+            result.runProtected(this, p);
+            result.endTest(this);
+        }
+    }
+
+    private DoubleTestCase fTest;
+
+    public TestImplementorTest() {
+        TestCase testCase = new TestCase() {
+            @Override
+            public void runTest() {
+            }
+        };
+        fTest = new DoubleTestCase(testCase);
+    }
+
+    public void testSuccessfulRun() {
+        TestResult result = new TestResult();
+        fTest.run(result);
+        assertEquals(fTest.countTestCases(), result.runCount());
+        assertEquals(0, result.errorCount());
+        assertEquals(0, result.failureCount());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/TestListenerTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/TestListenerTest.java
new file mode 100644
index 0000000..d59ba26
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/TestListenerTest.java
@@ -0,0 +1,80 @@
+package junit.tests.framework;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestListener;
+import junit.framework.TestResult;
+
+/**
+ * Test class used in SuiteTest
+ */
+public class TestListenerTest extends TestCase implements TestListener {
+    private TestResult fResult;
+    private int fStartCount;
+    private int fEndCount;
+    private int fFailureCount;
+    private int fErrorCount;
+
+    public void addError(Test test, Throwable e) {
+        fErrorCount++;
+    }
+
+    public void addFailure(Test test, AssertionFailedError t) {
+        fFailureCount++;
+    }
+
+    public void endTest(Test test) {
+        fEndCount++;
+    }
+
+    @Override
+    protected void setUp() {
+        fResult = new TestResult();
+        fResult.addListener(this);
+
+        fStartCount = 0;
+        fEndCount = 0;
+        fFailureCount = 0;
+        fErrorCount = 0;
+    }
+
+    public void startTest(Test test) {
+        fStartCount++;
+    }
+
+    public void testError() {
+        TestCase test = new TestCase("noop") {
+            @Override
+            public void runTest() {
+                throw new Error();
+            }
+        };
+        test.run(fResult);
+        assertEquals(1, fErrorCount);
+        assertEquals(1, fEndCount);
+    }
+
+    public void testFailure() {
+        TestCase test = new TestCase("noop") {
+            @Override
+            public void runTest() {
+                fail();
+            }
+        };
+        test.run(fResult);
+        assertEquals(1, fFailureCount);
+        assertEquals(1, fEndCount);
+    }
+
+    public void testStartStop() {
+        TestCase test = new TestCase("noop") {
+            @Override
+            public void runTest() {
+            }
+        };
+        test.run(fResult);
+        assertEquals(1, fStartCount);
+        assertEquals(1, fEndCount);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/ThreeTestCases.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/ThreeTestCases.java
new file mode 100644
index 0000000..c66b0db
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/ThreeTestCases.java
@@ -0,0 +1,17 @@
+package junit.tests.framework;
+
+import junit.framework.TestCase;
+
+/**
+ * Test class used in SuiteTest
+ */
+public class ThreeTestCases extends TestCase {
+    public void testCase() {
+    }
+
+    public void testCase2() {
+    }
+
+    public void testCase3thisTimeItsPersonal() {
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/framework/package-info.java b/google3/third_party/java_src/junit/test/java/junit/tests/framework/package-info.java
new file mode 100644
index 0000000..9cc0024
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/framework/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Tests the JUnit v3.x core classes.
+ */
+package junit.tests.framework;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/package-info.java b/google3/third_party/java_src/junit/test/java/junit/tests/package-info.java
new file mode 100644
index 0000000..d23121b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Tests the JUnit v3.x framework.
+ */
+package junit.tests;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/runner/AllTests.java b/google3/third_party/java_src/junit/test/java/junit/tests/runner/AllTests.java
new file mode 100644
index 0000000..63f2a6f
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/runner/AllTests.java
@@ -0,0 +1,30 @@
+package junit.tests.runner;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * TestSuite that runs all the sample tests
+ */
+public class AllTests {
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+    public static Test suite() { // Collect tests manually because we have to test class collection code
+        TestSuite suite = new TestSuite("Framework Tests");
+        suite.addTestSuite(StackFilterTest.class);
+        suite.addTestSuite(ResultTest.class);
+        suite.addTestSuite(BaseTestRunnerTest.class);
+        suite.addTestSuite(TextFeedbackTest.class);
+        suite.addTestSuite(TextRunnerSingleMethodTest.class);
+        suite.addTestSuite(TextRunnerTest.class);
+        return suite;
+    }
+
+    static boolean isJDK11() {
+        String version = System.getProperty("java.version");
+        return version.startsWith("1.1");
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/runner/BaseTestRunnerTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/runner/BaseTestRunnerTest.java
new file mode 100644
index 0000000..ea38bea
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/runner/BaseTestRunnerTest.java
@@ -0,0 +1,52 @@
+package junit.tests.runner;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import junit.runner.BaseTestRunner;
+
+public class BaseTestRunnerTest extends TestCase {
+    public static class MockRunner extends BaseTestRunner {
+        private boolean fRunFailed = false;
+
+        @Override
+        protected void runFailed(String message) {
+            fRunFailed = true;
+        }
+
+        @Override
+        public void testEnded(String testName) {
+        }
+
+        @Override
+        public void testFailed(int status, Test test, Throwable e) {
+        }
+
+        @Override
+        public void testStarted(String testName) {
+        }
+    }
+
+    public static class NonStatic {
+        public Test suite() {
+            return null;
+        }
+    }
+
+    public void testInvokeNonStaticSuite() {
+        BaseTestRunner runner = new MockRunner();
+        runner.getTest("junit.tests.runner.BaseTestRunnerTest$NonStatic"); // Used to throw NullPointerException
+    }
+
+    public static class DoesntExtendTestCase {
+        public static Test suite() {
+            return new TestSuite();
+        }
+    }
+
+    public void testInvokeSuiteOnNonSubclassOfTestCase() {
+        MockRunner runner = new MockRunner();
+        runner.getTest(DoesntExtendTestCase.class.getName());
+        assertFalse(runner.fRunFailed);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/runner/ResultTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/runner/ResultTest.java
new file mode 100644
index 0000000..8cd7ac2
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/runner/ResultTest.java
@@ -0,0 +1,189 @@
+package junit.tests.runner;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.List;
+
+import junit.framework.TestCase;
+import junit.tests.framework.Success;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.tests.running.methods.AnnotationTest;
+
+public class ResultTest extends TestCase {
+
+    private Result fromStream;
+
+    public void testRunFailureResultCanBeSerialised() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        Result result = runner.run(AnnotationTest.FailureTest.class);
+        assertResultSerializable(result);
+    }
+
+    public void testRunFailureResultCanBeReserialised_v4_12() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        Result result = runner.run(AnnotationTest.FailureTest.class);
+        assertResultReserializable(result, SerializationFormat.V4_12);
+    }
+
+    public void testRunAssumptionFailedResultCanBeSerialised() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        Result result = runner.run(AssumptionFailedTest.class);
+        assertResultSerializable(result);
+    }
+
+    public void testRunAssumptionFailedResultCanBeReserialised_v4_12() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        Result result = runner.run(AssumptionFailedTest.class);
+        assertResultReserializable(result, SerializationFormat.V4_12);
+    }
+
+    public void testRunAssumptionFailedResultCanBeReserialised_v4_13() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        Result result = runner.run(AssumptionFailedTest.class);
+        assertResultReserializable(result, SerializationFormat.V4_13);
+    }
+
+    public void testRunSuccessResultCanBeSerialised() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        Result result = runner.run(Success.class);
+        assertResultSerializable(result);
+    }
+
+    public void testRunSuccessResultCanBeReserialised_v4_12() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        Result result = runner.run(Success.class);
+        assertResultReserializable(result, SerializationFormat.V4_12);
+    }
+
+    public void testRunSuccessResultCanBeReserialised_v4_13() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        Result result = runner.run(Success.class);
+        assertResultReserializable(result, SerializationFormat.V4_13);
+    }
+
+    private enum SerializationFormat {
+        V4_12,
+        V4_13
+    }
+
+    private void assertResultSerializable(Result result) throws IOException, ClassNotFoundException {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
+        objectOutputStream.writeObject(result);
+        objectOutputStream.flush();
+        byte[] bytes = byteArrayOutputStream.toByteArray();
+        ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(bytes));
+        Result fromStream = (Result) objectInputStream.readObject();
+        assertSerializedCorrectly(result, fromStream, SerializationFormat.V4_13);
+    }
+ 
+    private void assertResultReserializable(Result result, SerializationFormat resourceSerializationFormat)
+            throws IOException, ClassNotFoundException {
+        String resourceName = getName();
+        InputStream resource = getClass().getResourceAsStream(resourceName);
+        assertNotNull("Could not read resource " + resourceName, resource);
+        ObjectInputStream objectInputStream = new ObjectInputStream(resource);
+        fromStream = (Result) objectInputStream.readObject();
+
+        assertSerializedCorrectly(new ResultWithFixedRunTime(result),
+                fromStream, resourceSerializationFormat);
+    }
+
+    public static class AssumptionFailedTest {
+        @Test
+        public void assumptionFailed() throws Exception {
+            org.junit.Assume.assumeTrue(false);
+        }
+    }
+
+    /**
+     * A version of {@code Result} that returns a hard-coded runtime.
+     * This makes values returned by the methods deterministic.
+     */
+    private static class ResultWithFixedRunTime extends Result {
+
+        private static final long serialVersionUID = 1L;
+
+        private final Result delegate;
+
+        public ResultWithFixedRunTime(Result delegate) {
+            this.delegate = delegate;
+        }
+
+        @Override
+        public int getRunCount() {
+            return delegate.getRunCount();
+        }
+
+        @Override
+        public int getFailureCount() {
+            return delegate.getFailureCount();
+        }
+
+        @Override
+        public long getRunTime() {
+            return 2;
+        }
+
+        @Override
+        public List<Failure> getFailures() {
+            return delegate.getFailures();
+        }
+
+        @Override
+        public int getIgnoreCount() {
+            return delegate.getIgnoreCount();
+        }
+
+        @Override
+        public int getAssumptionFailureCount() {
+            return delegate.getAssumptionFailureCount();
+        }
+    }
+
+    private void assertSerializedCorrectly(
+            Result result, Result fromStream, SerializationFormat serializationFormat) {
+        assertNotNull(fromStream);
+
+        // Exceptions don't implement equals() so we need to compare field by field
+        assertEquals("failureCount", result.getFailureCount(), fromStream.getFailureCount());
+        assertEquals("ignoreCount", result.getIgnoreCount(), fromStream.getIgnoreCount());
+
+        if (serializationFormat == SerializationFormat.V4_13) {
+            // assumption failures are serialized
+            assertEquals("assumptionFailureCount",
+                    result.getAssumptionFailureCount(),
+                    fromStream.getAssumptionFailureCount());
+        } else {
+            // assumption failures were not serialized
+            try {
+                fromStream.getAssumptionFailureCount();
+                fail("UnsupportedOperationException expected");
+            } catch (UnsupportedOperationException expected) {
+            }
+        }
+
+        assertEquals("runTime", result.getRunTime(), fromStream.getRunTime());
+        assertEquals("failures", result.getFailures().size(), fromStream.getFailures().size());
+        int index = 0;
+        for (Failure failure : result.getFailures()) {
+            Failure failureFromStream = fromStream.getFailures().get(index);
+            String messagePrefix = String.format("failures[%d]", index++);
+            assertEquals(messagePrefix + ".description",
+                    failure.getDescription(), failureFromStream.getDescription());
+            Throwable exception = failure.getException();
+            Throwable exceptionFromStream = failureFromStream.getException();
+            assertEquals(messagePrefix + ".exception",
+                    exception.getClass(), exceptionFromStream.getClass());
+            assertEquals(messagePrefix + ".exception",
+                    exception.getMessage(), exceptionFromStream.getMessage());
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/runner/StackFilterTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/runner/StackFilterTest.java
new file mode 100644
index 0000000..6aca9eb
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/runner/StackFilterTest.java
@@ -0,0 +1,46 @@
+package junit.tests.runner;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import junit.framework.TestCase;
+import junit.runner.BaseTestRunner;
+
+public class StackFilterTest extends TestCase {
+    String fFiltered;
+    String fUnfiltered;
+
+    @Override
+    protected void setUp() {
+        StringWriter swin = new StringWriter();
+        PrintWriter pwin = new PrintWriter(swin);
+        pwin.println("junit.framework.AssertionFailedError");
+        pwin.println("\tat junit.framework.Assert.fail(Assert.java:144)");
+        pwin.println("\tat junit.framework.Assert.assert(Assert.java:19)");
+        pwin.println("\tat junit.framework.Assert.assert(Assert.java:26)");
+        pwin.println("\tat MyTest.f(MyTest.java:13)");
+        pwin.println("\tat MyTest.testStackTrace(MyTest.java:8)");
+        pwin.println("\tat java.lang.reflect.Method.invoke(Native Method)");
+        pwin.println("\tat junit.framework.TestCase.runTest(TestCase.java:156)");
+        pwin.println("\tat junit.framework.TestCase.runBare(TestCase.java:130)");
+        pwin.println("\tat junit.framework.TestResult$1.protect(TestResult.java:100)");
+        pwin.println("\tat junit.framework.TestResult.runProtected(TestResult.java:118)");
+        pwin.println("\tat junit.framework.TestResult.run(TestResult.java:103)");
+        pwin.println("\tat junit.framework.TestCase.run(TestCase.java:121)");
+        pwin.println("\tat junit.framework.TestSuite.runTest(TestSuite.java:157)");
+        pwin.println("\tat junit.framework.TestSuite.run(TestSuite.java, Compiled Code)");
+        pwin.println("\tat junit.swingui.TestRunner$17.run(TestRunner.java:669)");
+        fUnfiltered = swin.toString();
+
+        StringWriter swout = new StringWriter();
+        PrintWriter pwout = new PrintWriter(swout);
+        pwout.println("junit.framework.AssertionFailedError");
+        pwout.println("\tat MyTest.f(MyTest.java:13)");
+        pwout.println("\tat MyTest.testStackTrace(MyTest.java:8)");
+        fFiltered = swout.toString();
+    }
+
+    public void testFilter() {
+        assertEquals(fFiltered, BaseTestRunner.getFilteredTrace(fUnfiltered));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/runner/TextFeedbackTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/runner/TextFeedbackTest.java
new file mode 100644
index 0000000..146a5ac
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/runner/TextFeedbackTest.java
@@ -0,0 +1,126 @@
+package junit.tests.runner;
+
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+import junit.textui.ResultPrinter;
+import junit.textui.TestRunner;
+
+public class TextFeedbackTest extends TestCase {
+    OutputStream output;
+    TestRunner runner;
+
+    static class TestResultPrinter extends ResultPrinter {
+        TestResultPrinter(PrintStream writer) {
+            super(writer);
+        }
+
+        /* Spoof printing time so the tests are deterministic
+           */
+        @Override
+        protected String elapsedTimeAsString(long runTime) {
+            return "0";
+        }
+    }
+
+    public static void main(String[] args) {
+        TestRunner.run(TextFeedbackTest.class);
+    }
+
+    @Override
+    public void setUp() {
+        output = new ByteArrayOutputStream();
+        runner = new TestRunner(new TestResultPrinter(new PrintStream(output)));
+    }
+
+    public void testEmptySuite() {
+        String expected = expected(new String[]{"", "Time: 0", "", "OK (0 tests)", ""});
+        runner.doRun(new TestSuite());
+        assertEquals(expected, output.toString());
+    }
+
+
+    public void testOneTest() {
+        String expected = expected(new String[]{".", "Time: 0", "", "OK (1 test)", ""});
+        TestSuite suite = new TestSuite();
+        suite.addTest(new TestCase() {
+            @Override
+            public void runTest() {
+            }
+        });
+        runner.doRun(suite);
+        assertEquals(expected, output.toString());
+    }
+
+    public void testTwoTests() {
+        String expected = expected(new String[]{"..", "Time: 0", "", "OK (2 tests)", ""});
+        TestSuite suite = new TestSuite();
+        suite.addTest(new TestCase() {
+            @Override
+            public void runTest() {
+            }
+        });
+        suite.addTest(new TestCase() {
+            @Override
+            public void runTest() {
+            }
+        });
+        runner.doRun(suite);
+        assertEquals(expected, output.toString());
+    }
+
+    public void testFailure() {
+        String expected = expected(new String[]{".F", "Time: 0", "Failures here", "", "FAILURES!!!", "Tests run: 1,  Failures: 1,  Errors: 0", ""});
+        ResultPrinter printer = new TestResultPrinter(new PrintStream(output)) {
+            @Override
+            public void printFailures(TestResult result) {
+                getWriter().println("Failures here");
+            }
+        };
+        runner.setPrinter(printer);
+        TestSuite suite = new TestSuite();
+        suite.addTest(new TestCase() {
+            @Override
+            public void runTest() {
+                throw new AssertionFailedError();
+            }
+        });
+        runner.doRun(suite);
+        assertEquals(expected, output.toString());
+    }
+
+    public void testError() {
+        String expected = expected(new String[]{".E", "Time: 0", "Errors here", "", "FAILURES!!!", "Tests run: 1,  Failures: 0,  Errors: 1", ""});
+        ResultPrinter printer = new TestResultPrinter(new PrintStream(output)) {
+            @Override
+            public void printErrors(TestResult result) {
+                getWriter().println("Errors here");
+            }
+        };
+        runner.setPrinter(printer);
+        TestSuite suite = new TestSuite();
+        suite.addTest(new TestCase() {
+            @Override
+            public void runTest() throws Exception {
+                throw new Exception();
+            }
+        });
+        runner.doRun(suite);
+        assertEquals(expected, output.toString());
+    }
+
+    private String expected(String[] lines) {
+        OutputStream expected = new ByteArrayOutputStream();
+        PrintStream expectedWriter = new PrintStream(expected);
+        for (int i = 0; i < lines.length; i++) {
+            expectedWriter.println(lines[i]);
+        }
+        return expected.toString();
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/runner/TextRunnerSingleMethodTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/runner/TextRunnerSingleMethodTest.java
new file mode 100644
index 0000000..fc3651a
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/runner/TextRunnerSingleMethodTest.java
@@ -0,0 +1,39 @@
+package junit.tests.runner;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+import junit.framework.TestCase;
+import junit.textui.ResultPrinter;
+import junit.textui.TestRunner;
+
+/**
+ * Test invoking a single test method of a TestCase.
+ */
+public class TextRunnerSingleMethodTest extends TestCase {
+
+    static boolean fgWasInvoked;
+
+    public static class InvocationTest extends TestCase {
+
+        public void testWasInvoked() {
+            TextRunnerSingleMethodTest.fgWasInvoked = true;
+        }
+
+        public void testNotInvoked() {
+            fail("Shouldn't get here.");
+        }
+    }
+
+    public void testSingle() throws Exception {
+        TestRunner t = new TestRunner();
+        t.setPrinter(new ResultPrinter(new PrintStream(new ByteArrayOutputStream())));
+        String[] args = {
+                "-m", "junit.tests.runner.TextRunnerSingleMethodTest$InvocationTest.testWasInvoked"
+        };
+        fgWasInvoked = false;
+        t.start(args);
+        assertTrue(fgWasInvoked);
+    }
+
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/runner/TextRunnerTest.java b/google3/third_party/java_src/junit/test/java/junit/tests/runner/TextRunnerTest.java
new file mode 100644
index 0000000..44e16fd
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/runner/TextRunnerTest.java
@@ -0,0 +1,62 @@
+package junit.tests.runner;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+
+public class TextRunnerTest extends TestCase {
+
+    public void testFailure() throws Exception {
+        execTest("junit.tests.framework.Failure", false);
+    }
+
+    public void testSuccess() throws Exception {
+        execTest("junit.tests.framework.Success", true);
+    }
+
+    public void testError() throws Exception {
+        execTest("junit.tests.BogusDude", false);
+    }
+
+    void execTest(String testClass, boolean success) throws Exception {
+        String java = System.getProperty("java.home") + File.separator + "bin" + File.separator + "java";
+        String cp = System.getProperty("java.class.path");
+        //use -classpath for JDK 1.1.7 compatibility
+        String[] cmd = {java, "-classpath", cp, "junit.textui.TestRunner", testClass};
+        Process p = Runtime.getRuntime().exec(cmd);
+        InputStream i = p.getInputStream();
+        while ((i.read()) != -1)
+            ;
+        assertTrue((p.waitFor() == 0) == success);
+        if (success) {
+            assertTrue(p.exitValue() == 0);
+        } else {
+            assertFalse(p.exitValue() == 0);
+        }
+    }
+
+    public void testRunReturnsResult() {
+        PrintStream oldOut = System.out;
+        System.setOut(new PrintStream(
+                new OutputStream() {
+                    @Override
+                    public void write(int arg0) throws IOException {
+                    }
+                }
+        ));
+        try {
+            TestResult result = junit.textui.TestRunner.run(new TestSuite());
+            assertTrue(result.wasSuccessful());
+        } finally {
+            System.setOut(oldOut);
+        }
+    }
+
+
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/junit/tests/runner/package-info.java b/google3/third_party/java_src/junit/test/java/junit/tests/runner/package-info.java
new file mode 100644
index 0000000..fc44e8a
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/junit/tests/runner/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Tests for the JUnit v3.x runner functionality.
+ */
+package junit.tests.runner;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/AssumptionViolatedExceptionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/AssumptionViolatedExceptionTest.java
new file mode 100644
index 0000000..f5dbfcb
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/AssumptionViolatedExceptionTest.java
@@ -0,0 +1,207 @@
+package org.junit;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assume.assumeThat;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.StringDescription;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.rules.TestName;
+import org.junit.runner.RunWith;
+
+@RunWith(Theories.class)
+public class AssumptionViolatedExceptionTest {
+    @DataPoint
+    public static Integer TWO = 2;
+
+    @DataPoint
+    public static Matcher<Integer> IS_THREE = is(3);
+
+    @DataPoint
+    public static Matcher<Integer> NULL = null;
+
+    @Rule
+    public TestName name = new TestName();
+
+    private static final String MESSAGE = "Assumption message";
+    private static Matcher<Integer> SERIALIZABLE_IS_THREE = new SerializableIsThreeMatcher<Integer>();
+    private static final UnserializableClass UNSERIALIZABLE_VALUE = new UnserializableClass();
+    private static final Matcher<UnserializableClass> UNSERIALIZABLE_MATCHER = not(is(UNSERIALIZABLE_VALUE));
+
+    @Theory
+    public void toStringReportsMatcher(Integer actual, Matcher<Integer> matcher) {
+        assumeThat(matcher, notNullValue());
+        assertThat(new AssumptionViolatedException(actual, matcher).toString(),
+                containsString(matcher.toString()));
+    }
+
+    @Theory
+    public void toStringReportsValue(Integer actual, Matcher<Integer> matcher) {
+        assertThat(new AssumptionViolatedException(actual, matcher).toString(),
+                containsString(String.valueOf(actual)));
+    }
+
+    @Test
+    public void assumptionViolatedExceptionWithMatcherDescribesItself() {
+        AssumptionViolatedException e = new AssumptionViolatedException(3, is(2));
+        assertThat(StringDescription.asString(e), is("got: <3>, expected: is <2>"));
+    }
+
+    @Test
+    public void simpleAssumptionViolatedExceptionDescribesItself() {
+        AssumptionViolatedException e = new AssumptionViolatedException("not enough money");
+        assertThat(StringDescription.asString(e), is("not enough money"));
+    }
+
+    @Test
+    public void canInitCauseWithInstanceCreatedWithString() {
+      AssumptionViolatedException e = new AssumptionViolatedException("invalid number");
+      Throwable cause = new RuntimeException("cause");
+      e.initCause(cause);
+      assertThat(e.getCause(), is(cause));
+    }
+
+    @Test
+    @SuppressWarnings("deprecation")
+    public void canSetCauseWithInstanceCreatedWithObjectAndMatcher() {
+      Throwable testObject = new Exception();
+      org.junit.internal.AssumptionViolatedException e
+              = new org.junit.internal.AssumptionViolatedException(
+                      testObject, containsString("test matcher"));
+      assertThat(e.getCause(), is(testObject));
+    }
+
+    @Test
+    @SuppressWarnings("deprecation")
+    public void canSetCauseWithInstanceCreatedWithAssumptionObjectAndMatcher() {
+      Throwable testObject = new Exception();
+      org.junit.internal.AssumptionViolatedException e
+              = new org.junit.internal.AssumptionViolatedException(
+                      "sample assumption", testObject, containsString("test matcher"));
+      assertThat(e.getCause(), is(testObject));
+    }
+
+    @Test
+    @SuppressWarnings("deprecation")
+    public void canSetCauseWithInstanceCreatedWithMainConstructor() {
+      Throwable testObject = new Exception();
+      org.junit.internal.AssumptionViolatedException e
+              = new org.junit.internal.AssumptionViolatedException(
+                      "sample assumption", false, testObject, containsString("test matcher"));
+      assertThat(e.getCause(), is(testObject));
+    }
+
+    @Test
+    public void canSetCauseWithInstanceCreatedWithExplicitThrowableConstructor() {
+      Throwable cause = new Exception();
+      AssumptionViolatedException e = new AssumptionViolatedException("invalid number", cause);
+      assertThat(e.getCause(), is(cause));
+    }
+
+    @Test
+    public void assumptionViolatedExceptionWithoutValueAndMatcherCanBeReserialized_v4_13()
+            throws IOException, ClassNotFoundException {
+        assertReserializable(new AssumptionViolatedException(MESSAGE));
+    }
+
+    @Test
+    public void assumptionViolatedExceptionWithValueAndMatcherCanBeReserialized_v4_13()
+            throws IOException, ClassNotFoundException {
+        assertReserializable(new AssumptionViolatedException(MESSAGE, TWO, SERIALIZABLE_IS_THREE));
+    }
+
+    @Test
+    public void unserializableValueAndMatcherCanBeSerialized() throws IOException, ClassNotFoundException {
+        AssumptionViolatedException exception = new AssumptionViolatedException(MESSAGE,
+                UNSERIALIZABLE_VALUE, UNSERIALIZABLE_MATCHER);
+
+        assertCanBeSerialized(exception);
+    }
+
+    @Test
+    public void nullValueAndMatcherCanBeSerialized() throws IOException, ClassNotFoundException {
+        AssumptionViolatedException exception = new AssumptionViolatedException(MESSAGE);
+
+        assertCanBeSerialized(exception);
+    }
+
+    @Test
+    public void serializableValueAndMatcherCanBeSerialized() throws IOException, ClassNotFoundException {
+        AssumptionViolatedException exception = new AssumptionViolatedException(MESSAGE,
+                TWO, SERIALIZABLE_IS_THREE);
+
+        assertCanBeSerialized(exception);
+    }
+
+    private void assertCanBeSerialized(AssumptionViolatedException exception)
+            throws IOException, ClassNotFoundException {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        ObjectOutputStream oos = new ObjectOutputStream(baos);
+        oos.writeObject(exception);
+
+        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+        ObjectInputStream ois = new ObjectInputStream(bais);
+        AssumptionViolatedException fromStream = (AssumptionViolatedException) ois.readObject();
+
+        assertSerializedCorrectly(exception, fromStream);
+    }
+
+    private void assertReserializable(AssumptionViolatedException expected)
+            throws IOException, ClassNotFoundException {
+        String resourceName = name.getMethodName();
+        InputStream resource = getClass().getResourceAsStream(resourceName);
+        assertNotNull("Could not read resource " + resourceName, resource);
+        ObjectInputStream objectInputStream = new ObjectInputStream(resource);
+        AssumptionViolatedException fromStream = (AssumptionViolatedException) objectInputStream.readObject();
+
+        assertSerializedCorrectly(expected, fromStream);
+    }
+
+    private void assertSerializedCorrectly(
+            AssumptionViolatedException expected, AssumptionViolatedException fromStream) {
+        assertNotNull(fromStream);
+
+        // Exceptions don't implement equals() so we need to compare field by field
+        assertEquals("message", expected.getMessage(), fromStream.getMessage());
+        assertEquals("description", StringDescription.asString(expected), StringDescription.asString(fromStream));
+        // We don't check the stackTrace as that will be influenced by how the test was started
+        // (e.g. by maven or directly from IDE)
+        // We also don't check the cause as that should already be serialized correctly by the superclass
+    }
+
+    private static class SerializableIsThreeMatcher<T> extends BaseMatcher<T> implements Serializable {
+
+        public boolean matches(Object item) {
+            return IS_THREE.matches(item);
+        }
+
+        public void describeTo(Description description) {
+            IS_THREE.describeTo(description);
+        }
+    }
+
+    private static class UnserializableClass {
+        @Override
+        public String toString() {
+            return "I'm not serializable";
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/AllCategoriesTests.java b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/AllCategoriesTests.java
new file mode 100644
index 0000000..6609bb8
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/AllCategoriesTests.java
@@ -0,0 +1,17 @@
+package org.junit.experimental.categories;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        CategoriesAndParameterizedTest.class,
+        CategoryFilterFactoryTest.class,
+        CategoryTest.class,
+        CategoryValidatorTest.class,
+        JavadocTest.class,
+        MultiCategoryTest.class
+})
+public class AllCategoriesTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoriesAndParameterizedTest.java b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoriesAndParameterizedTest.java
new file mode 100644
index 0000000..3d79222
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoriesAndParameterizedTest.java
@@ -0,0 +1,127 @@
+package org.junit.experimental.categories;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.experimental.categories.Categories.IncludeCategory;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.junit.runners.Suite.SuiteClasses;
+
+public class CategoriesAndParameterizedTest {
+    public static class Token {
+
+    }
+
+    @RunWith(Parameterized.class)
+    public static class ParameterizedTestWithoutCategory {
+        @Parameters
+        public static Iterable<String> getParameters() {
+            return Arrays.asList("first", "second");
+        }
+
+        @Parameterized.Parameter
+        public String value;
+
+        @Test
+        public void testSomething() {
+            Assert.assertTrue(true);
+        }
+    }
+
+    @Category(Token.class)
+    public static class TestThatAvoidsNoTestRemainsException {
+        @Test
+        public void testSomething() {
+            Assert.assertTrue(true);
+        }
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(Token.class)
+    @SuiteClasses({ TestThatAvoidsNoTestRemainsException.class,
+            ParameterizedTestWithoutCategory.class })
+    public static class SuiteWithParameterizedTestWithoutCategory {
+    }
+
+    @Test
+    public void doesNotRunTestsWithoutCategory() {
+        Result result = new JUnitCore()
+                .run(SuiteWithParameterizedTestWithoutCategory.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(0, result.getFailureCount());
+    }
+
+    @RunWith(Parameterized.class)
+    @Category(Token.class)
+    public static class ParameterizedTestWithCategory {
+        @Parameters
+        public static Iterable<String> getParameters() {
+            return Arrays.asList("first", "second");
+        }
+
+        @Parameterized.Parameter
+        public String value;
+
+        @Test
+        public void testSomething() {
+            Assert.assertTrue(true);
+        }
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(Token.class)
+    @SuiteClasses({ ParameterizedTestWithCategory.class })
+    public static class SuiteWithParameterizedTestWithCategory {
+    }
+
+    @Test
+    public void runsTestsWithoutCategory() {
+        Result result = new JUnitCore()
+                .run(SuiteWithParameterizedTestWithCategory.class);
+        assertEquals(2, result.getRunCount());
+        assertEquals(0, result.getFailureCount());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class ParameterizedTestWithMethodWithCategory {
+        @Parameters
+        public static Iterable<String> getParameters() {
+            return Arrays.asList("first", "second");
+        }
+
+        @Parameterized.Parameter
+        public String value;
+
+        @Test
+        @Category(Token.class)
+        public void testSomething() {
+            Assert.assertTrue(true);
+        }
+
+        @Test
+        public void testThatIsNotExecuted() {
+            Assert.assertTrue(true);
+        }
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(Token.class)
+    @SuiteClasses({ ParameterizedTestWithMethodWithCategory.class })
+    public static class SuiteWithParameterizedTestWithMethodWithCategory {
+    }
+
+    @Test
+    public void runsTestMethodWithCategory() {
+        Result result = new JUnitCore()
+                .run(SuiteWithParameterizedTestWithMethodWithCategory.class);
+        assertEquals(2, result.getRunCount());
+        assertEquals(0, result.getFailureCount());
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoryFilterFactoryTest.java b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoryFilterFactoryTest.java
new file mode 100644
index 0000000..f0bd7d5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoryFilterFactoryTest.java
@@ -0,0 +1,66 @@
+package org.junit.experimental.categories;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.runner.Description.createSuiteDescription;
+
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.rules.TestName;
+import org.junit.runner.Description;
+import org.junit.runner.FilterFactory;
+import org.junit.runner.FilterFactoryParams;
+import org.junit.runner.manipulation.Filter;
+
+public class CategoryFilterFactoryTest {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Rule
+    public TestName testName = new TestName();
+
+    private final CategoryFilterFactory categoryFilterFactory = new CategoryFilterFactoryStub();
+
+    @Test
+    public void shouldCreateFilter() throws Exception {
+        FilterFactoryParams params = new FilterFactoryParams(
+                createSuiteDescription(testName.getMethodName()),
+                CategoryFilterFactoryStub.class.getName());
+        Filter filter = categoryFilterFactory.createFilter(params);
+
+        assertThat(filter, instanceOf(DummyFilter.class));
+    }
+
+    @Test
+    public void shouldThrowException() throws Exception {
+        FilterFactoryParams params = new FilterFactoryParams(
+                createSuiteDescription(testName.getMethodName()),
+                "NonExistentFilter");
+
+        expectedException.expect(FilterFactory.FilterNotCreatedException.class);
+
+        categoryFilterFactory.createFilter(params);
+    }
+
+    private static class CategoryFilterFactoryStub extends CategoryFilterFactory {
+        @Override
+        protected Filter createFilter(List<Class<?>> categories) {
+            return new DummyFilter();
+        }
+    }
+
+    private static class DummyFilter extends Filter {
+        @Override
+        public boolean shouldRun(Description description) {
+            return false;
+        }
+
+        @Override
+        public String describe() {
+            return null;
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoryTest.java b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoryTest.java
new file mode 100644
index 0000000..6088f1d
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoryTest.java
@@ -0,0 +1,574 @@
+package org.junit.experimental.categories;
+
+import static java.lang.String.format;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.AnyOf.anyOf;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.failureCountIs;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Categories.CategoryFilter;
+import org.junit.experimental.categories.Categories.ExcludeCategory;
+import org.junit.experimental.categories.Categories.IncludeCategory;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+import org.junit.runners.model.InitializationError;
+
+public class CategoryTest {
+    public interface FastTests {
+        // category marker
+    }
+
+    public interface SlowTests {
+        // category marker
+    }
+
+    public interface ReallySlowTests {
+        // category marker
+    }
+
+    public static class OneOfEach {
+
+        @Category(FastTests.class)
+        @Test
+        public void a() {
+        }
+
+        @Category(SlowTests.class)
+        @Test
+        public void b() {
+        }
+
+        @Category(ReallySlowTests.class)
+        @Test
+        public void c() {
+        }
+    }
+
+    public static class A {
+        @Test
+        public void a() {
+            fail();
+        }
+
+        @Category(SlowTests.class)
+        @Test
+        public void b() {
+        }
+    }
+
+    @Category(SlowTests.class)
+    public static class B {
+        @Test
+        public void c() {
+
+        }
+    }
+
+    public static class C {
+        @Test
+        public void d() {
+            fail();
+        }
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(SlowTests.class)
+    @SuiteClasses({A.class, B.class, C.class})
+    public static class SlowTestSuite {
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(SlowTests.class)
+    @SuiteClasses({A.class})
+    public static class JustA {
+    }
+
+    @Test
+    public void testCountOnJustA() {
+        assertThat(testResult(JustA.class), isSuccessful());
+    }
+
+    @Test
+    public void testCount() {
+        assertThat(testResult(SlowTestSuite.class), isSuccessful());
+    }
+
+    public static class Category1 {
+    }
+
+    public static class Category2 {
+    }
+
+    public static class SomeAreSlow {
+        @Test
+        public void noCategory() {
+        }
+
+        @Category(Category1.class)
+        @Test
+        public void justCategory1() {
+        }
+
+        @Category(Category2.class)
+        @Test
+        public void justCategory2() {
+        }
+
+        @Category({Category1.class, Category2.class})
+        @Test
+        public void both() {
+        }
+
+        @Category({Category2.class, Category1.class})
+        @Test
+        public void bothReversed() {
+        }
+    }
+
+    @RunWith(Categories.class)
+    @ExcludeCategory(Category1.class)
+    @SuiteClasses({SomeAreSlow.class})
+    public static class SomeAreSlowSuite {
+    }
+
+    @Test
+    public void testCountOnAWithoutSlowTests() {
+        Result result = JUnitCore.runClasses(SomeAreSlowSuite.class);
+        assertThat(testResult(SomeAreSlowSuite.class), isSuccessful());
+        assertEquals(2, result.getRunCount());
+        assertTrue(result.wasSuccessful());
+    }
+
+    @RunWith(Categories.class)
+    @ExcludeCategory(Category1.class)
+    @IncludeCategory(Category2.class)
+    @SuiteClasses({SomeAreSlow.class})
+    public static class IncludeAndExcludeSuite {
+    }
+
+    @Test
+    public void testsThatAreBothIncludedAndExcludedAreExcluded() {
+        Result result = JUnitCore.runClasses(IncludeAndExcludeSuite.class);
+        assertEquals(1, result.getRunCount());
+        assertTrue(result.wasSuccessful());
+    }
+
+    @RunWith(Suite.class)
+    @SuiteClasses({A.class, B.class, C.class})
+    public static class TestSuiteWithNoCategories {
+    }
+
+    @Test
+    public void testCountWithExplicitIncludeFilter() throws Throwable {
+        CategoryFilter include = CategoryFilter.include(SlowTests.class);
+        Request baseRequest = Request.aClass(TestSuiteWithNoCategories.class);
+        Result result = new JUnitCore().run(baseRequest.filterWith(include));
+        assertTrue(result.wasSuccessful());
+        assertEquals(2, result.getRunCount());
+    }
+
+    @Test
+    public void testCountWithExplicitExcludeFilter() throws Throwable {
+        CategoryFilter include = CategoryFilter.exclude(SlowTests.class);
+        Request baseRequest = Request.aClass(TestSuiteWithNoCategories.class);
+        Result result = new JUnitCore().run(baseRequest.filterWith(include));
+        assertEquals(2, result.getFailureCount());
+        assertEquals(2, result.getRunCount());
+    }
+
+    @Test
+    public void testCountWithExplicitExcludeFilter_usingConstructor() throws Throwable {
+        CategoryFilter include = new CategoryFilter(null, SlowTests.class);
+        Request baseRequest = Request.aClass(TestSuiteWithNoCategories.class);
+        Result result = new JUnitCore().run(baseRequest.filterWith(include));
+        assertEquals(2, result.getFailureCount());
+        assertEquals(2, result.getRunCount());
+    }
+
+    @Test
+    public void categoryFilterLeavesOnlyMatchingMethods()
+            throws InitializationError, NoTestsRemainException {
+        CategoryFilter filter = CategoryFilter.include(SlowTests.class);
+        BlockJUnit4ClassRunner runner = new BlockJUnit4ClassRunner(A.class);
+        filter.apply(runner);
+        assertEquals(1, runner.testCount());
+    }
+
+    @Test
+    public void categoryFilterLeavesOnlyMatchingMethods_usingConstructor()
+            throws InitializationError, NoTestsRemainException {
+        CategoryFilter filter = new CategoryFilter(SlowTests.class, null);
+        BlockJUnit4ClassRunner runner = new BlockJUnit4ClassRunner(A.class);
+        filter.apply(runner);
+        assertEquals(1, runner.testCount());
+    }
+
+    public static class OneFastOneSlow {
+        @Category(FastTests.class)
+        @Test
+        public void a() {
+
+        }
+
+        @Category(SlowTests.class)
+        @Test
+        public void b() {
+
+        }
+    }
+
+    @Test
+    public void categoryFilterRejectsIncompatibleCategory()
+            throws InitializationError, NoTestsRemainException {
+        CategoryFilter filter = CategoryFilter.include(SlowTests.class);
+        BlockJUnit4ClassRunner runner = new BlockJUnit4ClassRunner(
+                OneFastOneSlow.class);
+        filter.apply(runner);
+        assertEquals(1, runner.testCount());
+    }
+
+    public static class OneFast {
+        @Category(FastTests.class)
+        @Test
+        public void a() {
+
+        }
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(SlowTests.class)
+    @SuiteClasses({OneFast.class})
+    public static class OneFastSuite {
+    }
+
+    @Test
+    public void ifNoTestsToRunUseErrorRunner() {
+        Result result = JUnitCore.runClasses(OneFastSuite.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(1, result.getFailureCount());
+        assertFalse(result.wasSuccessful());
+    }
+
+    @Test
+    public void describeACategoryFilter() {
+        CategoryFilter filter = CategoryFilter.include(SlowTests.class);
+        assertEquals("categories [" + SlowTests.class + "]", filter.describe());
+    }
+
+    @Test
+    public void describeMultipleCategoryFilter() {
+        CategoryFilter filter= CategoryFilter.include(FastTests.class, SlowTests.class);
+        String d1= format("categories [%s, %s]", FastTests.class, SlowTests.class);
+        String d2= format("categories [%s, %s]", SlowTests.class, FastTests.class);
+        assertThat(filter.describe(), is(anyOf(equalTo(d1), equalTo(d2))));
+    }
+
+
+    public static class OneThatIsBothFastAndSlow {
+        @Category({FastTests.class, SlowTests.class})
+        @Test
+        public void a() {
+
+        }
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(SlowTests.class)
+    @SuiteClasses({OneThatIsBothFastAndSlow.class})
+    public static class ChooseSlowFromBoth {
+    }
+
+    @Test
+    public void runMethodWithTwoCategories() {
+        assertThat(testResult(ChooseSlowFromBoth.class), isSuccessful());
+    }
+
+    public interface VerySlowTests extends SlowTests {
+
+    }
+
+    public static class OneVerySlowTest {
+        @Category(VerySlowTests.class)
+        @Test
+        public void a() {
+
+        }
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(SlowTests.class)
+    @SuiteClasses({OneVerySlowTest.class})
+    public static class RunSlowFromVerySlow {
+    }
+
+    @Test
+    public void subclassesOfIncludedCategoriesAreRun() {
+        assertThat(testResult(RunSlowFromVerySlow.class), isSuccessful());
+    }
+
+    public interface MultiA {
+    }
+
+    public interface MultiB {
+    }
+
+    public interface MultiC {
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(value= {MultiA.class, MultiB.class}, matchAny= false)
+    @SuiteClasses(AllIncludedMustMatched.class)
+    public static class AllIncludedMustBeMatchedSuite {
+    }
+
+    public static class AllIncludedMustMatched {
+        @Test
+        @Category({MultiA.class, MultiB.class})
+        public void a() {
+        }
+
+        @Test
+        @Category(MultiB.class)
+        public void b() {
+            fail("When multiple categories are included in a Suite, " +
+                    "@Test method must match all include categories");
+        }
+    }
+
+    @Test
+    public void allIncludedSuiteCategoriesMustBeMatched() {
+        Result result= JUnitCore.runClasses(AllIncludedMustBeMatchedSuite.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(0, result.getFailureCount());
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory({MultiA.class, MultiB.class})
+    @ExcludeCategory(MultiC.class)
+    @SuiteClasses(MultipleIncludesAndExcludeOnMethod.class)
+    public static class MultiIncludeWithExcludeCategorySuite {
+    }
+
+    public static class MultipleIncludesAndExcludeOnMethod {
+        @Test
+        @Category({MultiA.class, MultiB.class})
+        public void a() {
+        }
+
+        @Test
+        @Category({ MultiA.class, MultiB.class, MultiC.class })
+        public void b() {
+            fail("When multiple categories are included and excluded in a Suite, " +
+                    "@Test method must match all include categories and contain non of the excluded");
+        }
+    }
+
+    @Test
+    public void anyMethodWithExcludedCategoryWillBeExcluded() {
+        Result result= JUnitCore.runClasses(MultiIncludeWithExcludeCategorySuite.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(0, result.getFailureCount());
+    }
+
+    public static class ClassAsCategory {
+    }
+
+    public static class OneMoreTest {
+        @Category(ClassAsCategory.class)
+        @Test
+        public void a() {
+        }
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(ClassAsCategory.class)
+    @SuiteClasses({OneMoreTest.class})
+    public static class RunClassAsCategory {
+    }
+
+    @Test
+    public void classesCanBeCategories() {
+        assertThat(testResult(RunClassAsCategory.class), isSuccessful());
+    }
+
+    @Category(SlowTests.class)
+    public abstract static class Ancestor{}
+
+    public static class Inherited extends Ancestor {
+        @Test
+        public void a(){
+        }
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(SlowTests.class)
+    @SuiteClasses(Inherited.class)
+    public interface InheritanceSuite {}
+
+    @Test
+    public void testInheritance() {
+        Result result = JUnitCore.runClasses(InheritanceSuite.class);
+        assertEquals(1, result.getRunCount());
+        assertTrue(result.wasSuccessful());
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(Runnable.class)
+    @ExcludeCategory(Runnable.class)
+    @SuiteClasses({})
+    public static class EmptyCategoriesSuite {
+    }
+
+    @Test public void emptyCategoriesSuite() {
+        assertThat(testResult(EmptyCategoriesSuite.class), failureCountIs(1));
+    }
+
+    @Category(Runnable.class)
+    public static class NoTest {
+    }
+
+    @Category(Runnable.class)
+    public static class IgnoredTest {
+
+        @Ignore
+        @Test
+        public void test() {
+            fail();
+        }
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory(Runnable.class)
+    @SuiteClasses({NoTest.class, IgnoredTest.class})
+    public static class IgnoredTestCategoriesSuite {
+    }
+
+    @Test
+    public void ignoredTest() {// behaves same as Suite
+        Result result= JUnitCore.runClasses(IgnoredTestCategoriesSuite.class);
+        assertFalse(result.wasSuccessful());
+        assertThat(result.getRunCount(), is(1));
+        assertThat(result.getFailureCount(), is(1));
+        assertThat(result.getIgnoreCount(), is(1));
+    }
+
+    @Category(Runnable.class)
+    public static class ExcludedTest1 {
+
+        @Test
+        public void test() {
+            fail();
+        }
+    }
+
+    @Category(Runnable.class)
+    public static class ExcludedTest2 {
+
+        @Test
+        @Category(Runnable.class)
+        public void test() {
+            fail();
+        }
+    }
+
+    public static class IncludedTest {
+
+        @Test
+        @Category(Object.class)
+        public void test() {
+        }
+    }
+
+    @RunWith(Categories.class)
+    @IncludeCategory({Runnable.class, Object.class})
+    @ExcludeCategory(Runnable.class)
+    @SuiteClasses({ExcludedTest1.class, ExcludedTest2.class, IncludedTest.class})
+    public static class IncludedExcludedSameSuite {
+    }
+
+    @Test
+    public void oneRunnableOthersAvoided() {
+        Result result= JUnitCore.runClasses(IncludedExcludedSameSuite.class);
+        assertEquals(1, result.getRunCount());
+        assertTrue(result.wasSuccessful());
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testCountWithMultipleExcludeFilter() throws Throwable {
+        Set<Class<?>> exclusions= new HashSet<Class<?>>(2);
+        Collections.addAll(exclusions, SlowTests.class, FastTests.class);
+        CategoryFilter exclude = CategoryFilter.categoryFilter(true, null, true, exclusions);
+        Request baseRequest= Request.aClass(OneOfEach.class);
+        Result result= new JUnitCore().run(baseRequest.filterWith(exclude));
+        assertTrue(result.wasSuccessful());
+        assertEquals(1, result.getRunCount());
+    }
+
+    @Test
+    public void testCountWithMultipleIncludeFilter() throws Throwable {
+        CategoryFilter exclude = CategoryFilter.include(true, SlowTests.class, FastTests.class);
+        Request baseRequest= Request.aClass(OneOfEach.class);
+        Result result= new JUnitCore().run(baseRequest.filterWith(exclude));
+        assertTrue(result.wasSuccessful());
+        assertEquals(2, result.getRunCount());
+    }
+
+    @RunWith(Categories.class)
+    @Categories.ExcludeCategory(String.class)
+    @Suite.SuiteClasses(NoIncludeCategoryAnnotationTest.class)
+    public static class NoIncludeCategoryAnnotationSuite {
+    }
+
+    @Category(CharSequence.class)
+    public static class NoIncludeCategoryAnnotationTest {
+
+        @Test
+        public void test2() {
+        }
+
+        @Test
+        @Category(String.class) public void test1() {
+        }
+    }
+
+    @Test
+    public void noIncludeCategoryAnnotation() {
+        Result testResult= JUnitCore.runClasses(NoIncludeCategoryAnnotationSuite.class);
+        assertTrue(testResult.wasSuccessful());
+        assertEquals(1, testResult.getRunCount());
+    }
+
+    @RunWith(Categories.class)
+    @Categories.IncludeCategory(CharSequence.class)
+    @Categories.ExcludeCategory(String.class)
+    @Suite.SuiteClasses(NoIncludeCategoryAnnotationTest.class)
+    public static class SameAsNoIncludeCategoryAnnotationSuite {
+    }
+
+    @Test
+    public void sameAsNoIncludeCategoryAnnotation() {
+        Result testResult= JUnitCore.runClasses(SameAsNoIncludeCategoryAnnotationSuite.class);
+        assertTrue(testResult.wasSuccessful());
+        assertEquals(1, testResult.getRunCount());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoryValidatorTest.java b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoryValidatorTest.java
new file mode 100644
index 0000000..6d7c22e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/CategoryValidatorTest.java
@@ -0,0 +1,86 @@
+package org.junit.experimental.categories;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.List;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.TestClass;
+
+public class CategoryValidatorTest {
+
+    public static class SampleCategory {
+    }
+
+    public static class CategoryTest {
+        @BeforeClass
+        @Category(value = SampleCategory.class)
+        public static void methodWithCategoryAndBeforeClass() {
+        }
+
+        @AfterClass
+        @Category(value = SampleCategory.class)
+        public static void methodWithCategoryAndAfterClass() {
+        }
+
+        @Before
+        @Category(value = SampleCategory.class)
+        public static void methodWithCategoryAndBefore() {
+        }
+
+        @After
+        @Category(value = SampleCategory.class)
+        public static void methodWithCategoryAndAfter() {
+        }
+
+        @Category(value = SampleCategory.class)
+        public static void methodWithCategory() {
+        }
+    }
+
+    @Test
+    public void errorIsAddedWhenCategoryIsUsedWithBeforeClass() {
+        FrameworkMethod method = new TestClass(CategoryTest.class).getAnnotatedMethods(BeforeClass.class).get(0);
+        testAndAssertErrorMessage(method, "@BeforeClass can not be combined with @Category");
+    }
+
+    @Test
+    public void errorIsAddedWhenCategoryIsUsedWithAfterClass() {
+        FrameworkMethod method = new TestClass(CategoryTest.class).getAnnotatedMethods(AfterClass.class).get(0);
+        testAndAssertErrorMessage(method, "@AfterClass can not be combined with @Category");
+    }
+
+    @Test
+    public void errorIsAddedWhenCategoryIsUsedWithBefore() {
+        FrameworkMethod method = new TestClass(CategoryTest.class).getAnnotatedMethods(Before.class).get(0);
+        testAndAssertErrorMessage(method, "@Before can not be combined with @Category");
+    }
+
+    @Test
+    public void errorIsAddedWhenCategoryIsUsedWithAfter() {
+        FrameworkMethod method = new TestClass(CategoryTest.class).getAnnotatedMethods(After.class).get(0);
+        testAndAssertErrorMessage(method, "@After can not be combined with @Category");
+    }
+
+    private void testAndAssertErrorMessage(FrameworkMethod method, String expectedErrorMessage) {
+        List<Exception> errors = new CategoryValidator().validateAnnotatedMethod(method);
+
+        assertThat(errors.size(), is(1));
+        Exception exception = errors.get(0);
+        assertThat(exception.getMessage(), is(expectedErrorMessage));
+    }
+
+    @Test
+    public void errorIsNotAddedWhenCategoryIsNotCombinedWithIllegalCombination() throws NoSuchMethodException {
+        FrameworkMethod method = new FrameworkMethod(CategoryTest.class.getMethod("methodWithCategory"));
+        List<Exception> errors = new CategoryValidator().validateAnnotatedMethod(method);
+
+        assertThat(errors.size(), is(0));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/JavadocTest.java b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/JavadocTest.java
new file mode 100644
index 0000000..fc0df72
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/JavadocTest.java
@@ -0,0 +1,76 @@
+package org.junit.experimental.categories;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * @author tibor17
+ * @version 4.12
+ * @since 4.12
+ */
+public class JavadocTest {
+    public static interface FastTests {}
+    public static interface SlowTests {}
+    public static interface SmokeTests {}
+
+    public static class A {
+        public void a() {
+            fail();
+        }
+
+        @Category(SlowTests.class)
+        @Test
+        public void b() {
+        }
+
+        @Category({FastTests.class, SmokeTests.class})
+        @Test
+        public void c() {
+        }
+    }
+
+    @Category({SlowTests.class, FastTests.class})
+    public static class B {
+        @Test
+        public void d() {
+        }
+    }
+
+    @RunWith(Categories.class)
+    @Categories.IncludeCategory(SlowTests.class)
+    @Suite.SuiteClasses({A.class, B.class})
+    public static class SlowTestSuite {
+        // Will run A.b and B.d, but not A.a and A.c
+    }
+
+    @RunWith(Categories.class)
+    @Categories.IncludeCategory({FastTests.class, SmokeTests.class})
+    @Suite.SuiteClasses({A.class, B.class})
+    public static class FastOrSmokeTestSuite {
+        // Will run A.c and B.d, but not A.b because it is not any of FastTests or SmokeTests
+    }
+
+    @Test
+    public void slowTests() {
+        Result testResult= JUnitCore.runClasses(SlowTestSuite.class);
+        assertTrue(testResult.wasSuccessful());
+        assertThat("unexpected run count", testResult.getRunCount(), is(2));
+        assertThat("unexpected failure count", testResult.getFailureCount(), is(0));
+    }
+
+    @Test
+    public void fastSmokeTests() {
+        Result testResult= JUnitCore.runClasses(FastOrSmokeTestSuite.class);
+        assertTrue(testResult.wasSuccessful());
+        assertThat("unexpected run count", testResult.getRunCount(), is(2));
+        assertThat("unexpected failure count", testResult.getFailureCount(), is(0));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/MultiCategoryTest.java b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/MultiCategoryTest.java
new file mode 100644
index 0000000..68a580c
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/experimental/categories/MultiCategoryTest.java
@@ -0,0 +1,169 @@
+package org.junit.experimental.categories;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * @author tibor17
+ * @version 4.12
+ * @since 4.12
+ */
+public final class MultiCategoryTest {
+    public interface A {}
+    public interface B {}
+    public interface C {}
+
+    /**
+     * This test is mentioned in {@code Categories} and any changes
+     * must be reflected.
+     */
+    @Test
+    public void runSuite() {
+        // Targeting Test:
+        Result testResult= JUnitCore.runClasses(MultiCategorySuite.class);
+
+        assertThat("unexpected run count", testResult.getRunCount(), is(equalTo(2)));
+        assertThat("unexpected failure count", testResult.getFailureCount(), is(equalTo(0)));
+        assertThat("unexpected failure count", testResult.getIgnoreCount(), is(equalTo(0)));
+    }
+
+    @RunWith(Categories.class)
+    @Categories.IncludeCategory({A.class, B.class})
+    @Categories.ExcludeCategory(C.class)
+    @Suite.SuiteClasses({CategoriesTest.class})
+    public static final class MultiCategorySuite {}
+
+    public static final class CategoriesTest {
+
+        @Test
+        @Category(A.class)
+        public void a() {}
+
+        @Test
+        @Category(B.class)
+        public void b() {}
+
+        @Test
+        @Category(C.class)
+        public void c() {
+            fail();
+        }
+
+        @Test
+        public void anything() {
+            fail();
+        }
+    }
+
+    @Test
+    public void inheritanceAnyIncluded() {
+        Result testResult= JUnitCore.runClasses(InheritanceAny.class);
+        assertThat("unexpected run count", testResult.getRunCount(), is(equalTo(3)));
+        assertThat("unexpected failure count", testResult.getFailureCount(), is(equalTo(0)));
+        assertThat("unexpected failure count", testResult.getIgnoreCount(), is(equalTo(0)));
+    }
+
+    @Test
+    public void inheritanceAllIncluded() {
+        Result testResult= JUnitCore.runClasses(InheritanceAll.class);
+        assertThat("unexpected run count", testResult.getRunCount(), is(equalTo(1)));
+        assertThat("unexpected failure count", testResult.getFailureCount(), is(equalTo(0)));
+        assertThat("unexpected failure count", testResult.getIgnoreCount(), is(equalTo(0)));
+    }
+
+    @Test
+    public void inheritanceAnyAll() {//any included, all excluded
+        Result testResult= JUnitCore.runClasses(InheritanceAnyAll.class);
+        assertThat("unexpected run count", testResult.getRunCount(), is(equalTo(3)));
+        assertThat("unexpected failure count", testResult.getFailureCount(), is(equalTo(0)));
+        assertThat("unexpected failure count", testResult.getIgnoreCount(), is(equalTo(0)));
+    }
+
+    @Test
+    public void inheritanceAllAny() {//all included, any excluded
+        Result testResult= JUnitCore.runClasses(InheritanceAllAny.class);
+        assertThat("unexpected run count", testResult.getRunCount(), is(equalTo(1)));
+        assertThat("unexpected failure count", testResult.getFailureCount(), is(equalTo(1)));
+        assertThat("unexpected failure count", testResult.getIgnoreCount(), is(equalTo(0)));
+        assertFalse(testResult.wasSuccessful());
+    }
+
+    public static class X implements A {}
+    public static class Y implements B {}
+    public static class Z implements A, B {}
+    public static class W implements A, B, C {}
+    public static class Q implements A, C {}
+
+    @RunWith(Categories.class)
+    @Categories.IncludeCategory({A.class, B.class})
+    @Categories.ExcludeCategory(C.class)
+    @Suite.SuiteClasses({InheritanceAnyTest.class})
+    public static final class InheritanceAny {}
+
+    @RunWith(Categories.class)
+    @Categories.IncludeCategory(value= {A.class, B.class}, matchAny= false)
+    @Categories.ExcludeCategory(C.class)
+    @Suite.SuiteClasses({InheritanceAllTest.class})
+    public static final class InheritanceAll {}
+
+    @RunWith(Categories.class)
+    @Categories.IncludeCategory({A.class, B.class})
+    @Categories.ExcludeCategory(value= {A.class, C.class}, matchAny= false)
+    @Suite.SuiteClasses({InheritanceAnyAllTest.class})
+    public static final class InheritanceAnyAll {}
+
+    @RunWith(Categories.class)
+    @Categories.IncludeCategory(value= {A.class, B.class}, matchAny= false)
+    @Categories.ExcludeCategory({A.class, C.class})
+    @Suite.SuiteClasses({InheritanceAllAnyTest.class})
+    public static final class InheritanceAllAny {}
+
+    public static final class InheritanceAnyTest {
+        @Test @Category(X.class) public void x() {}
+        @Test @Category(Y.class) public void y() {}
+        @Test @Category(Z.class) public void z() {}
+        @Test @Category(W.class) public void w() { fail(); }
+        @Test @Category(Q.class) public void q() { fail(); }
+        @Test @Category(Runnable.class) public void runnable() { fail(); }
+        @Test public void t() { fail(); }
+    }
+
+    public static final class InheritanceAllTest {
+        @Test @Category(X.class) public void x() { fail(); }
+        @Test @Category(Y.class) public void y() { fail(); }
+        @Test @Category(Z.class) public void z() {}
+        @Test @Category(W.class) public void w() { fail(); }
+        @Test @Category(Q.class) public void q() { fail(); }
+        @Test @Category(Runnable.class) public void runnable() { fail(); }
+        @Test public void t() { fail(); }
+    }
+
+    public static final class InheritanceAnyAllTest {
+        @Test @Category(X.class) public void x() {}
+        @Test @Category(Y.class) public void y() {}
+        @Test @Category(Z.class) public void z() {}
+        @Test @Category(W.class) public void w() { fail(); }
+        @Test @Category(Q.class) public void q() { fail(); }
+        @Test @Category(Runnable.class) public void runnable() { fail(); }
+        @Test public void t() { fail(); }
+    }
+
+    public static final class InheritanceAllAnyTest {
+        @Test @Category(X.class) public void x() { fail(); }
+        @Test @Category(Y.class) public void y() { fail(); }
+        @Test @Category(Z.class) public void z() { fail(); }
+        @Test @Category(W.class) public void w() { fail(); }
+        @Test @Category(Q.class) public void q() { fail(); }
+        @Test @Category(Runnable.class) public void runnable() { fail(); }
+        @Test public void t() { fail(); }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/internal/AllInternalTests.java b/google3/third_party/java_src/junit/test/java/org/junit/internal/AllInternalTests.java
new file mode 100644
index 0000000..270d800
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/internal/AllInternalTests.java
@@ -0,0 +1,27 @@
+package org.junit.internal;
+
+import org.junit.internal.builders.AnnotatedBuilderTest;
+import org.junit.internal.matchers.StacktracePrintingMatcherTest;
+import org.junit.internal.matchers.ThrowableCauseMatcherTest;
+import org.junit.internal.runners.ErrorReportingRunnerTest;
+import org.junit.internal.runners.statements.ExpectExceptionTest;
+import org.junit.internal.runners.statements.FailOnTimeoutTest;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AnnotatedBuilderTest.class,
+        ChecksTest.class,
+        ErrorReportingRunnerTest.class,
+        ExpectExceptionTest.class,
+        FailOnTimeoutTest.class,
+        MethodSorterTest.class,
+        StacktracePrintingMatcherTest.class,
+        StackTracesTest.class,
+        ThrowableCauseMatcherTest.class,
+        ArrayComparisonFailureTest.class
+})
+public class AllInternalTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/internal/ArrayComparisonFailureTest.java b/google3/third_party/java_src/junit/test/java/org/junit/internal/ArrayComparisonFailureTest.java
new file mode 100644
index 0000000..93db649
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/internal/ArrayComparisonFailureTest.java
@@ -0,0 +1,68 @@
+package org.junit.internal;
+
+import org.junit.Test;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+public class ArrayComparisonFailureTest {
+
+    private static final String ARRAY_COMPARISON_FAILURE_411 = "arrayComparisonFailure_411";
+    private static final String ARRAY_COMPARISON_FAILURE_412 = "arrayComparisonFailure_412";
+
+    /*
+        Test compatibility of older versions of ArrayComparisonFailure
+        Setup:
+        - checkout prior versions of the codebase (r4.11, r4.12 in this case)
+        - catch the exception resulting from:
+            assertArrayEquals(new int[]{0, 1}, new int[]{0, 5});
+        - serialize the resulting exception to a file, moving into the test/resources path
+            Ex., for v4.11's resulting exception {@link org/junit/internal/arrayComparisonFailure_411}
+        Current unit test:
+        - deserialize the above files casting it to the current version of the class
+            (catches any forward incompatibility with missing fields)
+        - assert the results from existing methods: getCause(), toString() -> getMessage()
+            (catches incompatible usages of fields)
+
+        This does not test if an instance of the current version of the class is able to deserialize to a previous ver.
+     */
+
+    @Test
+    public void classShouldAccept411Version() throws Exception {
+        assertFailureSerializableFromOthers(ARRAY_COMPARISON_FAILURE_411);
+    }
+
+    @Test
+    public void classShouldAccept412Version() throws Exception {
+        assertFailureSerializableFromOthers(ARRAY_COMPARISON_FAILURE_412);
+    }
+
+    private void assertFailureSerializableFromOthers(String failureFileName) throws IOException,
+            ClassNotFoundException {
+        try {
+            assertArrayEquals(new int[]{0, 1}, new int[]{0, 5});
+            fail();
+        } catch (ArrayComparisonFailure e) {
+            ArrayComparisonFailure arrayComparisonFailureFromFile = deserializeFailureFromFile(failureFileName);
+            assertNotNull("ArrayComparisonFailure.getCause() should fallback to the deprecated fCause field"
+                            + " for compatibility with older versions of junit4 that didn't use Throwable.initCause().",
+                    arrayComparisonFailureFromFile.getCause());
+            assertEquals(e.getCause().toString(), arrayComparisonFailureFromFile.getCause().toString());
+            assertEquals(e.toString(), arrayComparisonFailureFromFile.toString());
+        }
+    }
+
+    private ArrayComparisonFailure deserializeFailureFromFile(String fileName) throws IOException,
+            ClassNotFoundException {
+        InputStream resource = getClass().getResourceAsStream(fileName);
+        ObjectInputStream objectInputStream = new ObjectInputStream(resource);
+        return (ArrayComparisonFailure) objectInputStream.readObject();
+    }
+
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/internal/ChecksTest.java b/google3/third_party/java_src/junit/test/java/org/junit/internal/ChecksTest.java
new file mode 100644
index 0000000..29cfbd1
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/internal/ChecksTest.java
@@ -0,0 +1,60 @@
+package org.junit.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+import static org.junit.internal.Checks.notNull;
+import org.junit.Test;
+
+/** Tests for {@link Checks}. */
+public class ChecksTest {
+
+    @Test
+    public void notNullShouldReturnNonNullValues() {
+        Double value = Double.valueOf(3.14);
+
+        Double result = notNull(value);
+
+        assertSame(value, result);
+    }
+
+    @Test
+    public void notNullShouldThrowOnNullValues() {
+        try {
+            notNull(null);
+            fail("NullPointerException expected");
+        } catch (NullPointerException e) {
+            assertNull("message should be null", e.getMessage());
+        }
+    }
+
+    @Test
+    public void notNullWithMessageShouldReturnNonNullValues() {
+        Float value = Float.valueOf(3.14f);
+
+        Float result = notNull(value, "woops");
+
+        assertSame(value, result);
+    }
+
+    @Test
+    public void notNullWithMessageShouldThrowOnNullValues() {
+        try {
+            notNull(null, "woops");
+            fail("NullPointerException expected");
+        } catch (NullPointerException e) {
+            assertEquals("message does not match", "woops", e.getMessage());
+        }
+    }
+
+    @Test
+    public void notNullWithNullMessageShouldThrowOnNullValues() {
+        try {
+            notNull(null, null);
+            fail("NullPointerException expected");
+        } catch (NullPointerException e) {
+            assertNull("message should be null", e.getMessage());
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/internal/MethodSorterTest.java b/google3/third_party/java_src/junit/test/java/org/junit/internal/MethodSorterTest.java
new file mode 100644
index 0000000..1934fa2
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/internal/MethodSorterTest.java
@@ -0,0 +1,182 @@
+package org.junit.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertArrayEquals;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+public class MethodSorterTest {
+    private static final String ALPHA = "java.lang.Object alpha(int,double,java.lang.Thread)";
+    private static final String BETA = "void beta(int[][])";
+    private static final String GAMMA_VOID = "int gamma()";
+    private static final String GAMMA_BOOLEAN = "void gamma(boolean)";
+    private static final String DELTA = "void delta()";
+    private static final String EPSILON = "void epsilon()";
+    private static final String SUPER_METHOD = "void superMario()";
+    private static final String SUB_METHOD = "void subBowser()";
+
+    static class DummySortWithoutAnnotation {
+        Object alpha(int i, double d, Thread t) {
+            return null;
+        }
+
+        void beta(int[][] x) {
+        }
+
+        int gamma() {
+            return 0;
+        }
+
+        void gamma(boolean b) {
+        }
+
+        void delta() {
+        }
+
+        void epsilon() {
+        }
+    }
+
+    static class Super {
+        void superMario() {
+        }
+    }
+
+    static class Sub extends Super {
+        void subBowser() {
+        }
+    }
+
+    private List<String> getDeclaredMethodNames(Class<?> clazz) {
+        Method[] actualMethods = MethodSorter.getDeclaredMethods(clazz);
+
+        // Obtain just the names instead of the full methods.
+        List<String> names = new ArrayList<String>();
+        for (Method m : actualMethods) {
+            // Filter out synthetic methods from, e.g., coverage tools.
+            if (!m.isSynthetic()) {
+                names.add(m.toString().replace(clazz.getName() + '.', ""));
+        	}
+        }
+        
+        return names;
+    }
+
+    @Test
+    public void testMethodsNullSorterSelf() {
+        List<String> expected = Arrays.asList(EPSILON, BETA, ALPHA, DELTA, GAMMA_VOID, GAMMA_BOOLEAN);
+        List<String> actual = getDeclaredMethodNames(DummySortWithoutAnnotation.class);
+        assertEquals(expected, actual);
+    }
+    
+    @Test
+    public void testMethodsNullSorterSuper() {
+        List<String> expected = Arrays.asList(SUPER_METHOD);
+        List<String> actual = getDeclaredMethodNames(Super.class);
+        assertEquals(expected, actual);
+    }
+    
+    @Test
+    public void testMethodsNullSorterSub() {
+        List<String> expected = Arrays.asList(SUB_METHOD);
+        List<String> actual = getDeclaredMethodNames(Sub.class);
+        assertEquals(expected, actual);
+    }
+
+    @FixMethodOrder(MethodSorters.DEFAULT)
+    static class DummySortWithDefault {
+        Object alpha(int i, double d, Thread t) {
+            return null;
+        }
+
+        void beta(int[][] x) {
+        }
+
+        int gamma() {
+            return 0;
+        }
+
+        void gamma(boolean b) {
+        }
+
+        void delta() {
+        }
+
+        void epsilon() {
+        }
+    }
+
+    @Test
+    public void testDefaultMethodSorter() {
+        List<String> expected = Arrays.asList(EPSILON, BETA, ALPHA, DELTA, GAMMA_VOID, GAMMA_BOOLEAN);
+        List<String> actual = getDeclaredMethodNames(DummySortWithDefault.class);
+        assertEquals(expected, actual);
+    }
+
+    @FixMethodOrder(MethodSorters.JVM)
+    static class DummySortJvm {
+        Object alpha(int i, double d, Thread t) {
+            return null;
+        }
+
+        void beta(int[][] x) {
+        }
+
+        int gamma() {
+            return 0;
+        }
+
+        void gamma(boolean b) {
+        }
+
+        void delta() {
+        }
+
+        void epsilon() {
+        }
+    }
+
+    @Test
+    public void testJvmMethodSorter() {
+        Method[] fromJvmWithSynthetics = DummySortJvm.class.getDeclaredMethods();
+        Method[] sorted = MethodSorter.getDeclaredMethods(DummySortJvm.class);
+        assertArrayEquals(fromJvmWithSynthetics, sorted);
+    }
+
+    @FixMethodOrder(MethodSorters.NAME_ASCENDING)
+    static class DummySortWithNameAsc {
+        Object alpha(int i, double d, Thread t) {
+            return null;
+        }
+
+        void beta(int[][] x) {
+        }
+
+        int gamma() {
+            return 0;
+        }
+
+        void gamma(boolean b) {
+        }
+
+        void delta() {
+        }
+
+        void epsilon() {
+        }
+    }
+
+    @Test
+    public void testAscendingMethodSorter() {
+        List<String> expected = Arrays.asList(ALPHA, BETA, DELTA, EPSILON, GAMMA_VOID, GAMMA_BOOLEAN);
+        List<String> actual = getDeclaredMethodNames(DummySortWithNameAsc.class);
+        assertEquals(expected, actual);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/internal/StackTracesTest.java b/google3/third_party/java_src/junit/test/java/org/junit/internal/StackTracesTest.java
new file mode 100644
index 0000000..5c0e8a1
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/internal/StackTracesTest.java
@@ -0,0 +1,332 @@
+package org.junit.internal;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.regex.Pattern;
+
+import junit.tests.SampleJUnit3Tests;
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.StringDescription;
+import org.hamcrest.TypeSafeMatcher;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.tests.SampleJUnit4Tests.*;
+
+public class StackTracesTest {
+    private static final String EOL = System.getProperty("line.separator", "\n");
+    private static ExecutorService executorService;
+
+    @BeforeClass
+    public static void startExecutorService() {
+        executorService = Executors.newFixedThreadPool(1);
+    }
+
+    @AfterClass
+    public static void shutDownExecutorService() {
+        executorService.shutdown();
+        executorService = null;
+    } 
+
+    @Test
+    public void getTrimmedStackForJUnit4TestFailingInTestMethod() {
+        Result result = runTest(TestWithOneThrowingTestMethod.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("One test should fail", 1, result.getFailureCount());
+        Failure failure = result.getFailures().get(0);
+
+        assertHasTrimmedTrace(failure,
+                message("java.lang.RuntimeException: cause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.doThrowExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.throwsExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$TestWithOneThrowingTestMethod.alwaysThrows"));
+        assertNotEquals(failure.getTrace(), failure.getTrimmedTrace());
+    }
+
+    @Test
+    public void getTrimmedStackForJUnit4TestFailingInTestMethodWithCause() {
+        Result result = runTest(TestWithOneThrowingTestMethodWithCause.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("One test should fail", 1, result.getFailureCount());
+        Failure failure = result.getFailures().get(0);
+
+        assertHasTrimmedTrace(failure,
+                message("java.lang.RuntimeException: outer"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.doThrowExceptionWithCause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.throwsExceptionWithCause"),
+                at("org.junit.tests.SampleJUnit4Tests$TestWithOneThrowingTestMethodWithCause.alwaysThrows"),
+                framesTrimmed(),
+                message("Caused by: java.lang.RuntimeException: cause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.doThrowExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.throwsExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.doThrowExceptionWithCause"),
+                framesInCommon());
+        assertNotEquals(failure.getTrace(), failure.getTrimmedTrace());
+    }
+
+    @Test
+    public void getTrimmedStackForJUnit4TestFailingInBeforeMethod() {
+        Result result = runTest(TestWithThrowingBeforeMethod.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("One test should fail", 1, result.getFailureCount());
+        Failure failure = result.getFailures().get(0);
+
+        assertHasTrimmedTrace(failure,
+                message("java.lang.RuntimeException: cause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.doThrowExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.throwsExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$TestWithThrowingBeforeMethod.alwaysThrows"));
+        assertNotEquals(failure.getTrace(), failure.getTrimmedTrace());
+    }
+
+    @Test
+    public void getTrimmedStackForJUnit3TestFailingInTestMethod() {
+        Result result = runTest(SampleJUnit3Tests.TestWithOneThrowingTestMethod.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("One test should fail", 1, result.getFailureCount());
+        Failure failure = result.getFailures().get(0);
+
+        assertHasTrimmedTrace(failure,
+                message("java.lang.RuntimeException: cause"),
+                at("junit.tests.SampleJUnit3Tests$FakeClassUnderTest.doThrowExceptionWithoutCause"),
+                at("junit.tests.SampleJUnit3Tests$FakeClassUnderTest.throwsExceptionWithoutCause"),
+                at("junit.tests.SampleJUnit3Tests$TestWithOneThrowingTestMethod.testAlwaysThrows"));
+        assertNotEquals(failure.getTrace(), failure.getTrimmedTrace());
+    }
+    
+    @Test
+    public void getTrimmedStackForJUnit3TestFailingInSetupMethod() {
+        Result result = runTest(SampleJUnit3Tests.TestWithThrowingSetUpMethod.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("One test should fail", 1, result.getFailureCount());
+        Failure failure = result.getFailures().get(0);
+
+        assertHasTrimmedTrace(failure,
+                message("java.lang.RuntimeException: cause"),
+                at("junit.tests.SampleJUnit3Tests$FakeClassUnderTest.doThrowExceptionWithoutCause"),
+                at("junit.tests.SampleJUnit3Tests$FakeClassUnderTest.throwsExceptionWithoutCause"),
+                at("junit.tests.SampleJUnit3Tests$TestWithThrowingSetUpMethod.setUp"));
+        assertNotEquals(failure.getTrace(), failure.getTrimmedTrace());
+    }
+
+    @Test
+    public void getTrimmedStackForJUnit4TestFailingInTestRule() {
+        Result result = runTest(TestWithThrowingTestRule.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("One test should fail", 1, result.getFailureCount());
+        Failure failure = result.getFailures().get(0);
+
+        assertHasTrimmedTrace(failure,
+                message("java.lang.RuntimeException: cause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.doThrowExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.throwsExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$ThrowingTestRule.apply"));
+        assertNotEquals(failure.getTrace(), failure.getTrimmedTrace());
+    }
+
+    @Test
+    public void getTrimmedStackForJUnit4TestFailingInClassRule() {
+        Result result = runTest(TestWithThrowingClassRule.class);
+        assertEquals("No tests were executed", 0, result.getRunCount());
+        assertEquals("One failure", 1, result.getFailureCount());
+        Failure failure = result.getFailures().get(0);
+
+        assertHasTrimmedTrace(failure,
+                message("java.lang.RuntimeException: cause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.doThrowExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.throwsExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$ThrowingTestRule.apply"));
+        assertNotEquals(failure.getTrace(), failure.getTrimmedTrace());
+    }
+
+    @Test
+    public void getTrimmedStackForJUnit4TestFailingInMethodRule() {
+        Result result = runTest(TestWithThrowingMethodRule.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("One test should fail", 1, result.getFailureCount());
+        Failure failure = result.getFailures().get(0);
+
+        assertHasTrimmedTrace(failure,
+                message("java.lang.RuntimeException: cause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.doThrowExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$FakeClassUnderTest.throwsExceptionWithoutCause"),
+                at("org.junit.tests.SampleJUnit4Tests$ThrowingMethodRule.apply"));
+        assertNotEquals(failure.getTrace(), failure.getTrimmedTrace());
+    }
+
+    @Test
+    public void getTrimmedStackWithSuppressedExceptions() {
+        assumeTrue("Running on 1.7+", TestWithSuppressedException.addSuppressed != null);
+        Result result = runTest(TestWithSuppressedException.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("One test should fail", 1, result.getFailureCount());
+        Failure failure = result.getFailures().get(0);
+
+        assertHasTrimmedTrace(failure,
+                message("java.lang.RuntimeException: error"),
+                at("org.junit.tests.SampleJUnit4Tests$TestWithSuppressedException.alwaysThrows"),
+                message("\tSuppressed: java.lang.RuntimeException: suppressed"),
+                at("org.junit.tests.SampleJUnit4Tests$TestWithSuppressedException.alwaysThrows"),
+                framesInCommon());
+        assertNotEquals(failure.getTrace(), failure.getTrimmedTrace());
+    }
+
+    private abstract static class StringMatcher extends TypeSafeMatcher<String> {
+    }
+
+    /**
+     * A matcher that matches the exception message in a stack trace.
+     */
+    private static class ExceptionMessageMatcher extends StringMatcher {
+        private final Matcher<String> matcher;
+
+        public ExceptionMessageMatcher(String message) {
+            matcher = CoreMatchers.equalTo(message);
+        }
+
+        public void describeTo(Description description) {
+            matcher.describeTo(description);
+        }
+
+        @Override
+        protected boolean matchesSafely(String line) {
+            return matcher.matches(line);
+        }
+    }
+
+    /** Returns a matcher that matches the message line in a stack trace. */
+    private static StringMatcher message(String message) {
+        return new ExceptionMessageMatcher(message);
+    }
+
+    /**
+     * A matcher that matches the "at ..." line in a stack trace.
+     */
+    private static class StackTraceLineMatcher extends StringMatcher {
+        private static final Pattern PATTERN
+                = Pattern.compile("\t*at ([a-zA-Z0-9.$]+)\\([a-zA-Z0-9]+\\.java:[0-9]+\\)");
+
+        private final String method;
+
+        public StackTraceLineMatcher(String method) {
+            this.method = method;
+        }
+
+        public void describeTo(Description description) {
+            description.appendText("A stack trace line for method " + method);
+        }
+
+        @Override
+        protected boolean matchesSafely(String line) {
+            if (!line.startsWith("\t")) {
+                return false;
+            }
+
+            line = line.substring(1);
+            java.util.regex.Matcher matcher = PATTERN.matcher(line);
+            if (!matcher.matches()) {
+                fail("Line does not look like a stack trace line: " + line);
+            }
+            String matchedMethod = matcher.group(1);
+            return method.equals(matchedMethod);
+        }
+    }
+
+    /** Returns a matcher that matches the "at ..." line in a stack trace. */
+    private static StringMatcher at(String method) {
+        return new StackTraceLineMatcher(method);
+    }
+
+    /**
+     * A matcher that matches the line printed when frames were removed from a stack trace.
+     */
+    private static class FramesRemovedMatcher extends StringMatcher {
+        private static final Pattern PATTERN
+                = Pattern.compile("\t*\\.\\.\\. [0-9]+ ([a-z]+)");
+
+        private final String suffix;
+
+        public FramesRemovedMatcher(String suffix) {
+            this.suffix = suffix;
+        }
+
+        public void describeTo(Description description) {
+            description.appendText("A line matching \"..x " + suffix + "\"");
+        }
+
+        @Override
+        protected boolean matchesSafely(String line) {
+            if (!line.startsWith("\t")) {
+                return false;
+            }
+            line = line.substring(1);
+
+            java.util.regex.Matcher matcher = PATTERN.matcher(line);
+            if (!matcher.matches()) {
+                fail("Line does not look like a stack trace line: " + line);
+            }
+            return suffix.equals(matcher.group(1));
+        }
+    }
+
+    /** Returns a matcher that matches the "\t...x more" line in a stack trace. */
+    private static StringMatcher framesInCommon() {
+        return new FramesRemovedMatcher("more");
+    }
+
+    /** Returns a matcher that matches the "\t...x trimmed" line in a stack trace. */
+    private static StringMatcher framesTrimmed() {
+        return new FramesRemovedMatcher("trimmed");
+    }
+
+    private static Result runTest(final Class<?> testClass) {
+        Future<Result> future = executorService.submit(new Callable<Result>() {
+            public Result call() throws Exception {
+                JUnitCore core = new JUnitCore();
+                return core.run(testClass);
+            }
+        });
+
+        try {
+            return future.get();
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Could not run test " + testClass, e);
+        } catch (ExecutionException e) {
+            throw new RuntimeException("Could not run test " + testClass, e);
+        }
+    }
+    
+    private static void assertHasTrimmedTrace(Failure failure, StringMatcher... matchers) {
+        String trimmedTrace = failure.getTrimmedTrace();
+        String[] lines = trimmedTrace.split(EOL);
+
+        int index = 0;
+        for (; index < lines.length && index < matchers.length; index++) {
+            String line = lines[index];
+            StringMatcher matcher = matchers[index];
+            assertThat(line, matcher);
+        }
+        if (index < lines.length) {
+            String extraLine = lines[index];
+            fail("Extra line in trimmed trace: " + extraLine);
+        } else if (index < matchers.length) {
+            StringDescription description = new StringDescription();
+            matchers[index].describeTo(description);
+            fail("Missing line in trimmed trace: " + description.toString());
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/internal/builders/AnnotatedBuilderTest.java b/google3/third_party/java_src/junit/test/java/org/junit/internal/builders/AnnotatedBuilderTest.java
new file mode 100644
index 0000000..8c8f095
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/internal/builders/AnnotatedBuilderTest.java
@@ -0,0 +1,105 @@
+package org.junit.internal.builders;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runner.RunnerSpy;
+import org.junit.runners.model.RunnerBuilder;
+import org.junit.runners.model.RunnerBuilderStub;
+
+public class AnnotatedBuilderTest {
+    private AnnotatedBuilder builder = new AnnotatedBuilder(new RunnerBuilderStub());
+
+    @Test
+    public void topLevelTestClassWithoutAnnotation_isRunWithDefaultRunner() throws Exception {
+        Runner runner = builder.runnerForClass(Object.class);
+        assertThat(runner, is(nullValue()));
+    }
+
+    @Test
+    public void topLevelTestClassWithAnnotation_isRunWithAnnotatedRunner() throws Exception {
+        Runner runner = builder.runnerForClass(OuterClass.class);
+        assertThat(runner, is(instanceOf(RunnerSpy.class)));
+
+        RunnerSpy runnerSpy = (RunnerSpy) runner;
+        assertThat(runnerSpy.getInvokedTestClass(), is((Object) OuterClass.class));
+    }
+
+    @Test
+    public void memberClassInsideAnnotatedTopLevelClass_isRunWithTopLevelRunner() throws Exception {
+        Runner runner = builder.runnerForClass(OuterClass.InnerClassWithoutOwnRunWith.class);
+        assertThat(runner, is(instanceOf(RunnerSpy.class)));
+
+        RunnerSpy runnerSpy = (RunnerSpy) runner;
+        assertThat(runnerSpy.getInvokedTestClass(), is((Object) OuterClass.InnerClassWithoutOwnRunWith.class));
+    }
+
+    @Test
+    public void memberClassDeepInsideAnnotatedTopLevelClass_isRunWithTopLevelRunner() throws Exception {
+        Runner runner = builder.runnerForClass(OuterClass.InnerClassWithoutOwnRunWith.MostInnerClass.class);
+        assertThat(runner, is(instanceOf(RunnerSpy.class)));
+
+        RunnerSpy runnerSpy = (RunnerSpy) runner;
+        assertThat(runnerSpy.getInvokedTestClass(), is((Object) OuterClass.InnerClassWithoutOwnRunWith.MostInnerClass.class));
+    }
+
+    @Test
+    public void annotatedMemberClassInsideAnnotatedTopLevelClass_isRunWithOwnRunner() throws Exception {
+        Runner runner = builder.runnerForClass(OuterClass.InnerClassWithOwnRunWith.class);
+        assertThat(runner, is(instanceOf(InnerRunner.class)));
+
+        RunnerSpy runnerSpy = (RunnerSpy) runner;
+        assertThat(runnerSpy.getInvokedTestClass(), is((Object) OuterClass.InnerClassWithOwnRunWith.class));
+    }
+
+    @Test
+    public void memberClassDeepInsideAnnotatedMemberClass_isRunWithParentMemberClassRunner() throws Exception {
+        Runner runner = builder.runnerForClass(OuterClass.InnerClassWithOwnRunWith.MostInnerClass.class);
+        assertThat(runner, is(instanceOf(InnerRunner.class)));
+
+        RunnerSpy runnerSpy = (RunnerSpy) runner;
+        assertThat(runnerSpy.getInvokedTestClass(), is((Object) OuterClass.InnerClassWithOwnRunWith.MostInnerClass.class));
+    }
+
+    @RunWith(RunnerSpy.class)
+    public static class OuterClass {
+        public class InnerClassWithoutOwnRunWith {
+            @Test
+            public void test() {
+            }
+
+            public class MostInnerClass {
+                @Test
+                public void test() {
+                }
+            }
+        }
+
+        @RunWith(InnerRunner.class)
+        public class InnerClassWithOwnRunWith {
+            @Test
+            public void test() {
+            }
+
+            public class MostInnerClass {
+                @Test
+                public void test() {
+                }
+            }
+        }
+    }
+
+    public static class InnerRunner extends RunnerSpy {
+        public InnerRunner(Class<?> testClass) {
+            super(testClass);
+        }
+
+        public InnerRunner(Class<?> testClass, RunnerBuilder runnerBuilder) {
+            super(testClass, runnerBuilder);
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/internal/matchers/StacktracePrintingMatcherTest.java b/google3/third_party/java_src/junit/test/java/org/junit/internal/matchers/StacktracePrintingMatcherTest.java
new file mode 100644
index 0000000..2f22c96
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/internal/matchers/StacktracePrintingMatcherTest.java
@@ -0,0 +1,38 @@
+package org.junit.internal.matchers;
+
+import static org.hamcrest.CoreMatchers.any;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.internal.matchers.StacktracePrintingMatcher.isException;
+import static org.junit.internal.matchers.StacktracePrintingMatcher.isThrowable;
+
+import org.junit.Test;
+
+public class StacktracePrintingMatcherTest {
+
+    @Test
+    public void succeedsWhenInnerMatcherSucceeds() throws Exception {
+        assertTrue(isThrowable(any(Throwable.class)).matches(new Exception()));
+    }
+
+    @Test
+    public void failsWhenInnerMatcherFails() throws Exception {
+        assertFalse(isException(notNullValue(Exception.class)).matches(null));
+    }
+
+    @Test
+    public void assertThatIncludesStacktrace() {
+        Exception actual = new IllegalArgumentException("my message");
+        Exception expected = new NullPointerException();
+
+        try {
+            assertThat(actual, isThrowable(equalTo(expected)));
+        } catch (AssertionError e) {
+            assertThat(e.getMessage(), containsString("Stacktrace was: java.lang.IllegalArgumentException: my message"));
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/internal/matchers/ThrowableCauseMatcherTest.java b/google3/third_party/java_src/junit/test/java/org/junit/internal/matchers/ThrowableCauseMatcherTest.java
new file mode 100644
index 0000000..8a169c7
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/internal/matchers/ThrowableCauseMatcherTest.java
@@ -0,0 +1,18 @@
+package org.junit.internal.matchers;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.internal.matchers.ThrowableCauseMatcher.hasCause;
+
+public class ThrowableCauseMatcherTest {
+
+    @Test
+    public void shouldAllowCauseOfDifferentClassFromRoot() throws Exception {
+        NullPointerException expectedCause = new NullPointerException("expected");
+        Exception actual = new Exception(expectedCause);
+
+        assertThat(actual, hasCause(is(expectedCause)));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/internal/runners/ErrorReportingRunnerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/internal/runners/ErrorReportingRunnerTest.java
new file mode 100644
index 0000000..e8263e5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/internal/runners/ErrorReportingRunnerTest.java
@@ -0,0 +1,88 @@
+package org.junit.internal.runners;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.model.InvalidTestClassError;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class ErrorReportingRunnerTest {
+    
+    @Test(expected = NullPointerException.class)
+    public void cannotCreateWithNullClass() {
+        new ErrorReportingRunner(null, new RuntimeException());
+    }
+    
+    @Test(expected = NullPointerException.class)
+    public void cannotCreateWithNullClass2() {
+        new ErrorReportingRunner(new RuntimeException(), (Class<?>) null);
+    }
+    
+    @Test(expected = NullPointerException.class)
+    public void cannotCreateWithNullClasses() {
+        new ErrorReportingRunner(new RuntimeException(), (Class<?>[]) null);
+    }
+    
+    @Test(expected = NullPointerException.class)
+    public void cannotCreateWithoutClass() {
+        new ErrorReportingRunner(new RuntimeException());
+    }
+
+    @Test
+    public void givenInvalidTestClassErrorAsCause() {
+        final List<Failure> firedFailures = new ArrayList<Failure>();
+        InvalidTestClassError testClassError = new InvalidTestClassError(TestClassWithErrors.class,
+                Arrays.asList(new Throwable("validation error 1"), new Throwable("validation error 2")));
+        ErrorReportingRunner sut = new ErrorReportingRunner(TestClassWithErrors.class, testClassError);
+
+        sut.run(new RunNotifier() {
+            @Override
+            public void fireTestFailure(Failure failure) {
+                super.fireTestFailure(failure);
+                firedFailures.add(failure);
+            }
+        });
+
+        assertThat(firedFailures.size(), is(1));
+        Throwable exception = firedFailures.get(0).getException();
+        assertThat(exception, instanceOf(InvalidTestClassError.class));
+        assertThat(((InvalidTestClassError) exception), is(testClassError));
+    }
+
+    @Test
+    public void givenInvalidTestClass_integrationTest() {
+        Result result = JUnitCore.runClasses(TestClassWithErrors.class);
+
+        assertThat(result.getFailureCount(), is(1));
+        Throwable failure = result.getFailures().get(0).getException();
+        assertThat(failure, instanceOf(InvalidTestClassError.class));
+        assertThat(failure.getMessage(), allOf(
+                startsWith("Invalid test class '" + TestClassWithErrors.class.getName() + "'"),
+                containsString("\n  1. "),
+                containsString("\n  2. ")
+        ));
+    }
+
+    private static class TestClassWithErrors {
+        @Before public static void staticBeforeMethod() {}
+        @After public static void staticAfterMethod() {}
+
+        @Test public String testMethodReturningString() {
+            return "this should not be allowed";
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/internal/runners/statements/ExpectExceptionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/internal/runners/statements/ExpectExceptionTest.java
new file mode 100644
index 0000000..466e289
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/internal/runners/statements/ExpectExceptionTest.java
@@ -0,0 +1,88 @@
+package org.junit.internal.runners.statements;
+
+import org.junit.Test;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runners.model.Statement;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.fail;
+
+/**
+ * Integration tests can be found in {@link org.junit.tests.running.methods.ExpectedTest}.
+ * See e.g. {@link org.junit.tests.running.methods.ExpectedTest#expectsAssumptionViolatedException()}
+ */
+public class ExpectExceptionTest {
+
+    @Test
+    public void whenExpectingAssumptionViolatedExceptionStatementsThrowingItShouldPass() {
+        Statement delegate = new Fail(new AssumptionViolatedException("expected"));
+        ExpectException expectException = new ExpectException(delegate, AssumptionViolatedException.class);
+
+        try {
+            expectException.evaluate();
+            // then AssumptionViolatedException should not be thrown
+        } catch (Throwable e) { // need to explicitly catch and re-throw as an AssertionError or it might be skipped
+            fail("should not throw anything, but was thrown: " + e);
+        }
+    }
+
+    @Test
+    public void whenExpectingAssumptionViolatedExceptionStatementsThrowingSubclassShouldPass() {
+        Statement delegate = new Fail(new AssumptionViolatedExceptionSubclass("expected"));
+        ExpectException expectException = new ExpectException(delegate, AssumptionViolatedException.class);
+
+        try {
+            expectException.evaluate();
+            // then no exception should be thrown
+        } catch (Throwable e) {
+            fail("should not throw anything, but was thrown: " + e);
+        }
+    }
+
+    @Test
+    public void whenExpectingAssumptionViolatedExceptionStatementsThrowingDifferentExceptionShouldFail() {
+        Statement delegate = new Fail(new SomeException("not expected"));
+        ExpectException expectException = new ExpectException(delegate, AssumptionViolatedException.class);
+
+        try {
+            expectException.evaluate();
+            fail("should throw 'Unexpected exception' when statement throws an exception which is not the one expected");
+        } catch (Exception e) {
+            assertThat(e.getMessage(), equalTo("Unexpected exception, expected<org.junit.internal.AssumptionViolatedException> " +
+                    "but was<org.junit.internal.runners.statements.ExpectExceptionTest$SomeException>"));
+        }
+    }
+
+    @Test
+    public void whenExpectingAssumptionViolatedExceptionStatementsPassingShouldFail() throws Exception {
+        ExpectException expectException = new ExpectException(new PassingStatement(), AssumptionViolatedException.class);
+
+        try {
+            expectException.evaluate();
+        } catch (AssertionError e) {
+            assertThat(e.getMessage(), containsString("Expected exception: " + AssumptionViolatedException.class.getName()));
+            return;
+        }
+        fail("ExpectException should throw when the given statement passes");
+    }
+
+    private static class PassingStatement extends Statement {
+        public void evaluate() throws Throwable {
+            // nop
+        }
+    }
+
+    private static class SomeException extends RuntimeException {
+        public SomeException(String message) {
+            super(message);
+        }
+    }
+
+    private static class AssumptionViolatedExceptionSubclass extends AssumptionViolatedException {
+        public AssumptionViolatedExceptionSubclass(String assumption) {
+            super(assumption);
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/internal/runners/statements/FailOnTimeoutTest.java b/google3/third_party/java_src/junit/test/java/org/junit/internal/runners/statements/FailOnTimeoutTest.java
new file mode 100644
index 0000000..8bf7823
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/internal/runners/statements/FailOnTimeoutTest.java
@@ -0,0 +1,271 @@
+package org.junit.internal.runners.statements;
+
+import static java.lang.Long.MAX_VALUE;
+import static java.lang.Math.atan;
+import static java.lang.System.currentTimeMillis;
+import static java.lang.Thread.currentThread;
+import static java.lang.Thread.interrupted;
+import static java.lang.Thread.sleep;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeFalse;
+import static org.junit.Assume.assumeTrue;
+
+import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.junit.runners.model.Statement;
+import org.junit.runners.model.TestTimedOutException;
+
+
+/**
+ * @author Asaf Ary, Stefan Birkner
+ */
+@RunWith(Parameterized.class)
+public class FailOnTimeoutTest {
+
+    @Parameters(name = "lookingForStuckThread = {0}")
+    public static Iterable<Boolean> getParameters() {
+        return Arrays.asList(Boolean.TRUE, Boolean.FALSE);
+    }
+
+    @Parameter
+    public boolean lookingForStuckThread;
+
+    @Test
+    public void noExceptionIsThrownWhenWrappedStatementFinishesBeforeTimeoutWithoutThrowingException()
+            throws Throwable {
+        FailOnTimeout failOnTimeout = failAfter50Ms(new FastStatement());
+
+        failOnTimeout.evaluate();
+
+        // test is successful when no exception is thrown
+    }
+
+    @Test
+    public void throwsTestTimedOutExceptionWithMeaningfulMessage() {
+        Exception e = assertThrows(
+                TestTimedOutException.class,
+                run(failAfter50Ms(new RunForASecond())));
+        assertEquals("test timed out after 50 milliseconds", e.getMessage());
+    }
+
+    @Test
+    public void sendUpExceptionThrownByStatement() {
+        Exception exception = new RuntimeException();
+        Exception e = assertThrows(
+                Exception.class,
+                run(failAfter50Ms(new Fail(exception))));
+        assertSame(exception, e);
+    }
+
+    @Test
+    public void throwExceptionIfTheSecondCallToEvaluateNeedsTooMuchTime()
+            throws Throwable {
+        DelegatingStatement statement = new DelegatingStatement();
+        FailOnTimeout failOnTimeout = failAfter50Ms(statement);
+
+        statement.delegate = new FastStatement();
+        failOnTimeout.evaluate();
+
+        statement.delegate = new RunForASecond();
+        assertThrows(
+                TestTimedOutException.class,
+                run(failOnTimeout));
+    }
+
+    @Test
+    public void throwTimeoutExceptionOnSecondCallAlthoughFirstCallThrowsException() {
+        DelegatingStatement statement = new DelegatingStatement();
+        FailOnTimeout failOnTimeout = failAfter50Ms(statement);
+
+        statement.delegate = new Fail(new AssertionError("first execution failed"));
+        assertThrows(
+                AssertionError.class,
+                run(failOnTimeout)
+        );
+
+        statement.delegate = new RunForASecond();
+        assertThrows(
+                TestTimedOutException.class,
+                run(failOnTimeout));
+    }
+
+    @Test
+    public void throwsExceptionWithTimeoutValueAndTimeUnitSet() {
+        TestTimedOutException e = assertThrows(
+                TestTimedOutException.class,
+                run(failAfter50Ms(new RunForASecond())));
+        assertEquals(50, e.getTimeout());
+        assertEquals(MILLISECONDS, e.getTimeUnit());
+    }
+
+    @Test
+    public void statementThatCanBeInterruptedIsStoppedAfterTimeout() throws Throwable {
+        // RunForASecond can be interrupted because it checks the Thread's
+        // interrupted flag.
+        RunForASecond runForASecond = new RunForASecond();
+        assertThrows(
+                TestTimedOutException.class,
+                run(failAfter50Ms(runForASecond)));
+
+        // Thread is explicitly stopped if it finishes faster than its
+        // pre-defined execution time of one second.
+        boolean stopped = runForASecond.finished.await(50, MILLISECONDS);
+        assertTrue("Thread has not been stopped.", stopped);
+    }
+
+    @Test
+    public void stackTraceContainsRealCauseOfTimeout() {
+        TestTimedOutException timedOutException = assertThrows(
+                TestTimedOutException.class,
+                run(failAfter50Ms(new StuckStatement())));
+
+        StackTraceElement[] stackTrace = timedOutException.getStackTrace();
+        boolean stackTraceContainsTheRealCauseOfTheTimeout = false;
+        boolean stackTraceContainsOtherThanTheRealCauseOfTheTimeout = false;
+        for (StackTraceElement element : stackTrace) {
+            String methodName = element.getMethodName();
+            if ("theRealCauseOfTheTimeout".equals(methodName)) {
+                stackTraceContainsTheRealCauseOfTheTimeout = true;
+            }
+            if ("notTheRealCauseOfTheTimeout".equals(methodName)) {
+                stackTraceContainsOtherThanTheRealCauseOfTheTimeout = true;
+            }
+        }
+        assertTrue(
+                "Stack trace does not contain the real cause of the timeout",
+                stackTraceContainsTheRealCauseOfTheTimeout);
+        assertFalse(
+                "Stack trace contains other than the real cause of the timeout, which can be very misleading",
+                stackTraceContainsOtherThanTheRealCauseOfTheTimeout);
+    }
+
+    private static final class StuckStatement extends Statement {
+
+        @Override
+        public void evaluate() throws Throwable {
+            try {
+                // Must show up in stack trace
+                theRealCauseOfTheTimeout();
+            } catch (InterruptedException e) {
+            } finally {
+                // Must _not_ show up in stack trace
+                notTheRealCauseOfTheTimeout();
+            }
+        }
+
+        private void theRealCauseOfTheTimeout() throws InterruptedException {
+            sleep(MAX_VALUE);
+        }
+
+        private void notTheRealCauseOfTheTimeout() {
+            for (long now = currentTimeMillis(), eta = now + 1000L; now < eta; now = currentTimeMillis()) {
+                // Doesn't matter, just pretend to be busy
+                atan(now);
+            }
+        }
+    }
+
+    @Test
+    public void lookingForStuckThread_threadGroupNotLeaked() throws Throwable {
+        assumeTrue(lookingForStuckThread);
+        final AtomicReference<ThreadGroup> innerThreadGroup = new AtomicReference<ThreadGroup>();
+        final AtomicReference<Thread> innerThread = new AtomicReference<Thread>();
+        final ThreadGroup outerThreadGroup = currentThread().getThreadGroup();
+        FailOnTimeout failOnTimeout = failAfter50Ms(new Statement() {
+            @Override
+            public void evaluate() {
+                innerThread.set(currentThread());
+                ThreadGroup group = currentThread().getThreadGroup();
+                assertNotSame("inner thread should use a different thread group",
+                        outerThreadGroup, group);
+                innerThreadGroup.set(group);
+                assertTrue("the 'FailOnTimeoutGroup' thread group should be a daemon thread group",
+                        group.isDaemon());
+            }
+        });
+
+        failOnTimeout.evaluate();
+
+        assertNotNull("the Statement was never run", innerThread.get());
+        innerThread.get().join();
+        assertTrue("the 'FailOnTimeoutGroup' thread group should be destroyed after running the test",
+                innerThreadGroup.get().isDestroyed());
+    }
+
+    @Test
+    public void notLookingForStuckThread_usesSameThreadGroup() throws Throwable {
+        assumeFalse(lookingForStuckThread);
+        final AtomicBoolean statementWasExecuted = new AtomicBoolean();
+        final ThreadGroup outerThreadGroup = currentThread().getThreadGroup();
+        FailOnTimeout failOnTimeout = failAfter50Ms(new Statement() {
+            @Override
+            public void evaluate() {
+                statementWasExecuted.set(true);
+                ThreadGroup group = currentThread().getThreadGroup();
+                assertSame("inner thread should use the same thread group", outerThreadGroup, group);
+            }
+        });
+
+        failOnTimeout.evaluate();
+
+        assertTrue("the Statement was never run", statementWasExecuted.get());
+    }
+
+    private FailOnTimeout failAfter50Ms(Statement statement) {
+        return FailOnTimeout.builder()
+                .withTimeout(50, MILLISECONDS)
+                .withLookingForStuckThread(lookingForStuckThread)
+                .build(statement);
+    }
+
+    private ThrowingRunnable run(final FailOnTimeout failOnTimeout) {
+        return new ThrowingRunnable() {
+            public void run() throws Throwable {
+                failOnTimeout.evaluate();
+            }
+        };
+    }
+
+    private static class DelegatingStatement extends Statement {
+        volatile Statement delegate;
+
+        @Override
+        public void evaluate() throws Throwable {
+            delegate.evaluate();
+        }
+    }
+
+    private static class FastStatement extends Statement {
+        @Override
+        public void evaluate() throws Throwable {
+        }
+    }
+
+    private static final class RunForASecond extends Statement {
+        final CountDownLatch finished = new CountDownLatch(1);
+
+        @Override
+        public void evaluate() throws Throwable {
+            long timeout = currentTimeMillis() + 1000L;
+            while (!interrupted() && currentTimeMillis() < timeout) {
+            }
+            finished.countDown();
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/AllRulesTests.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/AllRulesTests.java
new file mode 100644
index 0000000..8b63e15
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/AllRulesTests.java
@@ -0,0 +1,31 @@
+package org.junit.rules;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        BlockJUnit4ClassRunnerOverrideTest.class,
+        ClassRulesTest.class,
+        DisableOnDebugTest.class,
+        ErrorCollectorTest.class,
+        ExpectedExceptionTest.class,
+        ExternalResourceRuleTest.class,
+        MethodRulesTest.class,
+        NameRulesTest.class,
+        RuleChainTest.class,
+        RuleMemberValidatorTest.class,
+        StopwatchTest.class,
+        TempFolderRuleTest.class,
+        TemporaryFolderRuleAssuredDeletionTest.class,
+        TemporaryFolderUsageTest.class,
+        TestRuleTest.class,
+        TestWatcherTest.class,
+        TestWatchmanTest.class,
+        TestWatchmanTest.class,
+        TimeoutRuleTest.class,
+        VerifierRuleTest.class
+})
+public class AllRulesTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/BlockJUnit4ClassRunnerOverrideTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/BlockJUnit4ClassRunnerOverrideTest.java
new file mode 100644
index 0000000..4f85be0
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/BlockJUnit4ClassRunnerOverrideTest.java
@@ -0,0 +1,175 @@
+package org.junit.rules;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.RunWith;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+
+public class BlockJUnit4ClassRunnerOverrideTest {
+    public static class FlipBitRule implements MethodRule {
+        public Statement apply(final Statement base, FrameworkMethod method,
+                final Object target) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    target.getClass().getField("flipBit").set(target, true);
+                    base.evaluate();
+                }
+            };
+        }
+
+    }
+
+    public static class OverrideRulesRunner extends BlockJUnit4ClassRunner {
+        public OverrideRulesRunner(Class<?> klass) throws InitializationError {
+            super(klass);
+        }
+
+        @Override
+        protected List<MethodRule> rules(Object test) {
+            final LinkedList<MethodRule> methodRules = new LinkedList<MethodRule>(
+                    super.rules(test));
+            methodRules.add(new FlipBitRule());
+            return methodRules;
+        }
+    }
+
+    @RunWith(OverrideRulesRunner.class)
+    public static class OverrideRulesTest {
+        public boolean flipBit = false;
+
+        @Test
+        public void testFlipBit() {
+            assertTrue(flipBit);
+        }
+    }
+
+    @Test
+    public void overrideRulesMethod() {
+        assertThat(testResult(OverrideTestRulesTest.class), isSuccessful());
+    }
+
+    public static class OverrideTestRulesRunner extends BlockJUnit4ClassRunner {
+        public OverrideTestRulesRunner(Class<?> klass)
+                throws InitializationError {
+            super(klass);
+        }
+
+        @Override
+        protected List<TestRule> getTestRules(final Object test) {
+            final LinkedList<TestRule> methodRules = new LinkedList<TestRule>(
+                    super.getTestRules(test));
+            methodRules.add(new TestRule() {
+                public Statement apply(Statement base, Description description) {
+                    return new FlipBitRule().apply(base, null, test);
+                }
+            });
+            return methodRules;
+        }
+    }
+
+    @RunWith(OverrideTestRulesRunner.class)
+    public static class OverrideTestRulesTest extends OverrideRulesTest {
+    }
+
+    @Test
+    public void overrideTestRulesMethod() {
+        assertThat(testResult(OverrideRulesTest.class), isSuccessful());
+    }
+
+
+    /**
+     * Runner for testing override of {@link org.junit.runners.BlockJUnit4ClassRunner#createTest(org.junit.runners.model.FrameworkMethod)}
+     * by setting the {@link org.junit.runners.model.FrameworkMethod} in a field
+     * of the test class so it can be compared with the test method that is being
+     * executed.
+     */
+    public static class OverrideCreateTestRunner extends BlockJUnit4ClassRunner {
+        public OverrideCreateTestRunner(final Class<?> klass) throws InitializationError {
+            super(klass);
+
+            assert(klass.equals(OverrideCreateTest.class));
+        }
+
+        @Override
+        protected Object createTest(FrameworkMethod method) {
+            final OverrideCreateTest obj = new OverrideCreateTest();
+
+            obj.method = method;
+
+            return obj;
+        }
+    }
+
+    @RunWith(OverrideCreateTestRunner.class)
+    public static class OverrideCreateTest {
+        public FrameworkMethod method;
+
+        @Test
+        public void testMethodA() {
+            assertEquals("testMethodA", method.getMethod().getName());
+        }
+
+        @Test
+        public void testMethodB() {
+            assertEquals("testMethodB", method.getMethod().getName());
+        }
+    }
+
+    @Test
+    public void overrideCreateTestMethod() {
+        assertThat(testResult(OverrideCreateTest.class), isSuccessful());
+    }
+
+
+    /**
+     * Runner for testing override of {@link org.junit.runners.BlockJUnit4ClassRunner#createTest()}
+     * is still called by default if no other {@code createTest} method override
+     * is in place. This is tested by setting a boolean flag in a field of the
+     * test class so it can be checked to confirm that the createTest method was
+     * called.
+     */
+    public static class CreateTestDefersToNoArgCreateTestRunner extends BlockJUnit4ClassRunner {
+        public CreateTestDefersToNoArgCreateTestRunner(final Class<?> klass) throws InitializationError {
+            super(klass);
+
+            assert(klass.equals(CreateTestDefersToNoArgCreateTestTest.class));
+        }
+
+        @Override
+        protected Object createTest() {
+            final CreateTestDefersToNoArgCreateTestTest obj = new CreateTestDefersToNoArgCreateTestTest();
+
+            obj.createTestCalled = true;
+
+            return obj;
+        }
+    }
+
+    @RunWith(CreateTestDefersToNoArgCreateTestRunner.class)
+    public static class CreateTestDefersToNoArgCreateTestTest {
+        public boolean createTestCalled = false;
+
+        @Test
+        public void testCreateTestCalled() {
+            assertEquals(true, createTestCalled);
+        }
+    }
+
+    @Test
+    public void createTestDefersToNoArgCreateTest() {
+        assertThat(testResult(CreateTestDefersToNoArgCreateTestTest.class), isSuccessful());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/ClassRulesTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/ClassRulesTest.java
new file mode 100644
index 0000000..ddfb744
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/ClassRulesTest.java
@@ -0,0 +1,366 @@
+/*
+ * Created Oct 19, 2009
+ */
+package org.junit.rules;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.ClassRule;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.MethodSorters;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+
+/**
+ * Tests to exercise class-level rules.
+ */
+public class ClassRulesTest {
+    public static class Counter extends ExternalResource {
+        public int count = 0;
+
+        @Override
+        protected void before() throws Throwable {
+            count++;
+        }
+    }
+
+    public static class ExampleTestWithClassRule {
+        @ClassRule
+        public static Counter counter = new Counter();
+
+        @Test
+        public void firstTest() {
+            assertEquals(1, counter.count);
+        }
+
+        @Test
+        public void secondTest() {
+            assertEquals(1, counter.count);
+        }
+    }
+
+    @Test
+    public void ruleIsAppliedOnce() {
+        ExampleTestWithClassRule.counter.count = 0;
+        JUnitCore.runClasses(ExampleTestWithClassRule.class);
+        assertEquals(1, ExampleTestWithClassRule.counter.count);
+    }
+
+    public static class SubclassOfTestWithClassRule extends
+            ExampleTestWithClassRule {
+
+    }
+
+    @Test
+    public void ruleIsIntroducedAndEvaluatedOnSubclass() {
+        ExampleTestWithClassRule.counter.count = 0;
+        JUnitCore.runClasses(SubclassOfTestWithClassRule.class);
+        assertEquals(1, ExampleTestWithClassRule.counter.count);
+    }
+
+    public static class CustomCounter implements TestRule {
+        public int count = 0;
+
+        public Statement apply(final Statement base, Description description) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    count++;
+                    base.evaluate();
+                }
+            };
+        }
+    }
+
+    public static class ExampleTestWithCustomClassRule {
+        @ClassRule
+        public static CustomCounter counter = new CustomCounter();
+
+        @Test
+        public void firstTest() {
+            assertEquals(1, counter.count);
+        }
+
+        @Test
+        public void secondTest() {
+            assertEquals(1, counter.count);
+        }
+    }
+
+
+    @Test
+    public void customRuleIsAppliedOnce() {
+        ExampleTestWithCustomClassRule.counter.count = 0;
+        Result result = JUnitCore.runClasses(ExampleTestWithCustomClassRule.class);
+        assertTrue(result.wasSuccessful());
+        assertEquals(1, ExampleTestWithCustomClassRule.counter.count);
+    }
+
+    private static final List<String> orderList = new LinkedList<String>();
+
+    private static class OrderTestRule implements TestRule {
+        private String name;
+
+        public OrderTestRule(String name) {
+            this.name = name;
+        }
+
+        public Statement apply(final Statement base, final Description description) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    orderList.add(name);
+                    base.evaluate();
+                }
+            };
+        }
+    }
+
+    public static class UsesFieldAndMethodRule {
+        @ClassRule
+        public static OrderTestRule orderMethod() {
+            return new OrderTestRule("orderMethod");
+        }
+
+        @ClassRule
+        public static OrderTestRule orderField = new OrderTestRule("orderField");
+
+        @Test
+        public void foo() {
+            assertEquals("orderField", orderList.get(0));
+            assertEquals("orderMethod", orderList.get(1));
+        }
+    }
+
+    @Test
+    public void usesFieldAndMethodRule() {
+        orderList.clear();
+        assertThat(testResult(UsesFieldAndMethodRule.class), isSuccessful());
+    }
+
+
+    public static class MethodExampleTestWithClassRule {
+        private static Counter counter = new Counter();
+
+        @ClassRule
+        public static Counter getCounter() {
+            return counter;
+        }
+
+        @Test
+        public void firstTest() {
+            assertEquals(1, counter.count);
+        }
+
+        @Test
+        public void secondTest() {
+            assertEquals(1, counter.count);
+        }
+    }
+
+    @Test
+    public void methodRuleIsAppliedOnce() {
+        MethodExampleTestWithClassRule.counter.count = 0;
+        JUnitCore.runClasses(MethodExampleTestWithClassRule.class);
+        assertEquals(1, MethodExampleTestWithClassRule.counter.count);
+    }
+
+    public static class MethodSubclassOfTestWithClassRule extends
+            MethodExampleTestWithClassRule {
+
+    }
+
+    @Test
+    public void methodRuleIsIntroducedAndEvaluatedOnSubclass() {
+        MethodExampleTestWithClassRule.counter.count = 0;
+        JUnitCore.runClasses(MethodSubclassOfTestWithClassRule.class);
+        assertEquals(1, MethodExampleTestWithClassRule.counter.count);
+    }
+
+    public static class MethodExampleTestWithCustomClassRule {
+        private static CustomCounter counter = new CustomCounter();
+
+        @ClassRule
+        public static CustomCounter getCounter() {
+            return counter;
+        }
+
+        @Test
+        public void firstTest() {
+            assertEquals(1, counter.count);
+        }
+
+        @Test
+        public void secondTest() {
+            assertEquals(1, counter.count);
+        }
+    }
+
+
+    @Test
+    public void methodCustomRuleIsAppliedOnce() {
+        MethodExampleTestWithCustomClassRule.counter.count = 0;
+        Result result = JUnitCore.runClasses(MethodExampleTestWithCustomClassRule.class);
+        assertTrue(result.wasSuccessful());
+        assertEquals(1, MethodExampleTestWithCustomClassRule.counter.count);
+    }
+
+    public static class CallMethodOnlyOnceRule {
+        static int countOfMethodCalls = 0;
+
+        private static class Dummy implements TestRule {
+            public Statement apply(final Statement base, Description description) {
+                return new Statement() {
+                    @Override
+                    public void evaluate() throws Throwable {
+                        base.evaluate();
+                    }
+                };
+            }
+        }
+
+        @ClassRule
+        public static Dummy both() {
+            countOfMethodCalls++;
+            return new Dummy();
+        }
+
+        @Test
+        public void onlyOnce() {
+            assertEquals(1, countOfMethodCalls);
+        }
+    }
+
+    @Test
+    public void testCallMethodOnlyOnceRule() {
+        CallMethodOnlyOnceRule.countOfMethodCalls = 0;
+        assertTrue(JUnitCore.runClasses(CallMethodOnlyOnceRule.class).wasSuccessful());
+    }
+
+    private static final StringBuilder log = new StringBuilder();
+
+    @FixMethodOrder(MethodSorters.NAME_ASCENDING)
+    public static class ClassRuleOrdering {
+        @ClassRule(order = 1)
+        public static TestRule a() {
+            return new LoggingTestRule(log, "outer");
+        }
+
+        @ClassRule(order = 2)
+        public static TestRule z() {
+            return new LoggingTestRule(log, "inner");
+        }
+
+        @Test
+        public void foo() {
+            log.append(" foo");
+        }
+
+        @Test
+        public void bar() {
+            log.append(" bar");
+        }
+    }
+
+    @Test
+    public void classRuleOrdering() {
+        log.setLength(0);
+        Result result = JUnitCore.runClasses(ClassRuleOrdering.class);
+        assertTrue(result.wasSuccessful());
+        assertEquals(" outer.begin inner.begin bar foo inner.end outer.end", log.toString());
+    }
+
+    @FixMethodOrder(MethodSorters.NAME_ASCENDING)
+    public static class ClassRuleOrderingDefault {
+        @ClassRule
+        public static TestRule a() {
+            return new LoggingTestRule(log, "outer");
+        }
+
+        @ClassRule
+        public static TestRule b() {
+            return new LoggingTestRule(log, "inner");
+        }
+
+        @Test
+        public void foo() {
+            log.append(" foo");
+        }
+
+        @Test
+        public void bar() {
+            log.append(" bar");
+        }
+    }
+
+    @Test
+    public void classRuleOrderingDefault() {
+        log.setLength(0);
+        Result result = JUnitCore.runClasses(ClassRuleOrderingDefault.class);
+        assertTrue(result.wasSuccessful());
+        assertEquals(" inner.begin outer.begin bar foo outer.end inner.end", log.toString());
+    }
+
+    public static class RunnerWithClassRuleAddedProgrammatically extends BlockJUnit4ClassRunner {
+        public RunnerWithClassRuleAddedProgrammatically(Class testClass) throws InitializationError {
+            super(testClass);
+        }
+
+        @Override
+        protected List<TestRule> classRules() {
+            final List<TestRule> rules = super.classRules();
+            rules.add(new LoggingTestRule(log, "fromCode"));
+            return rules;
+        }
+    }
+
+    @RunWith(RunnerWithClassRuleAddedProgrammatically.class)
+    public static class ClassRulesModifiableListEmpty {
+        @Test
+        public void test() {
+            log.append(" test");
+        }
+    }
+
+    @Test
+    public void classRulesModifiableListEmpty() {
+        log.setLength(0);
+        Result result = JUnitCore.runClasses(ClassRulesModifiableListEmpty.class);
+        assertTrue(result.wasSuccessful());
+        assertEquals(" fromCode.begin test fromCode.end", log.toString());
+    }
+
+    @RunWith(RunnerWithClassRuleAddedProgrammatically.class)
+    public static class ClassRulesModifiableList {
+        @ClassRule
+        public static TestRule classRule() {
+            return new LoggingTestRule(log, "classRule");
+        }
+
+        @Test
+        public void test() {
+            log.append(" test");
+        }
+    }
+
+    @Test
+    public void classRulesModifiableList() {
+        log.setLength(0);
+        Result result = JUnitCore.runClasses(ClassRulesModifiableList.class);
+        assertTrue(result.wasSuccessful());
+        assertEquals(" fromCode.begin classRule.begin test classRule.end fromCode.end", log.toString());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/DisableOnDebugTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/DisableOnDebugTest.java
new file mode 100644
index 0000000..8bf6b9d
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/DisableOnDebugTest.java
@@ -0,0 +1,164 @@
+package org.junit.rules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runners.model.Statement;
+
+public class DisableOnDebugTest {
+    private static final List<String> WITHOUT_DEBUG_ARGUMENTS = Collections
+            .emptyList();
+
+    private static final List<String> PRE_JAVA5_DEBUG_ARGUMENTS = Arrays
+            .asList("-Xdebug",
+                    "-Xrunjdwp:transport=dt_socket,server=y,address=8000");
+
+    private static final List<String> PRE_JAVA5_DEBUG_ARGUMENTS_IN_REVERSE_ORDER = Arrays
+            .asList("-Xrunjdwp:transport=dt_socket,server=y,address=8000",
+                    "-Xdebug");
+
+    private static final List<String> POST_JAVA5_DEBUG_ARGUMENTS = Arrays
+            .asList("-agentlib:jdwp=transport=dt_socket,server=y,address=8000");
+
+    /**
+     * Nasty rule that always fails
+     */
+    private static class FailOnExecution implements TestRule {
+
+        public Statement apply(Statement base,
+                Description description) {
+            return new Statement() {
+
+                @Override
+                public void evaluate() throws Throwable {
+                    throw new AssertionError();
+                }
+            };
+        }
+
+    }
+
+    public abstract static class AbstractDisableOnDebugTest {
+
+        @Rule
+        public TestRule failOnExecution;
+
+        public AbstractDisableOnDebugTest(List<String> arguments) {
+            this.failOnExecution = new DisableOnDebug(new FailOnExecution(),
+                    arguments);
+        }
+
+        @Test
+        public void test() {
+        }
+    }
+
+    public static class PreJava5DebugArgumentsTest extends
+            AbstractDisableOnDebugTest {
+
+        public PreJava5DebugArgumentsTest() {
+            super(PRE_JAVA5_DEBUG_ARGUMENTS);
+        }
+
+    }
+
+    public static class PreJava5DebugArgumentsReversedTest extends
+            AbstractDisableOnDebugTest {
+
+        public PreJava5DebugArgumentsReversedTest() {
+            super(PRE_JAVA5_DEBUG_ARGUMENTS_IN_REVERSE_ORDER);
+        }
+
+    }
+
+    public static class PostJava5DebugArgumentsTest extends
+            AbstractDisableOnDebugTest {
+
+        public PostJava5DebugArgumentsTest() {
+            super(POST_JAVA5_DEBUG_ARGUMENTS);
+        }
+
+    }
+
+    public static class WithoutDebugArgumentsTest extends
+            AbstractDisableOnDebugTest {
+
+        public WithoutDebugArgumentsTest() {
+            super(WITHOUT_DEBUG_ARGUMENTS);
+        }
+
+    }
+
+    @Test
+    public void givenPreJava5DebugArgumentsIsDebuggingShouldReturnTrue() {
+        DisableOnDebug subject = new DisableOnDebug(
+                new FailOnExecution(), PRE_JAVA5_DEBUG_ARGUMENTS);
+        assertTrue("Should be debugging", subject.isDebugging());
+    }
+
+    @Test
+    public void givenPreJava5DebugArgumentsInReverseIsDebuggingShouldReturnTrue() {
+        DisableOnDebug subject = new DisableOnDebug(
+                new FailOnExecution(),
+                PRE_JAVA5_DEBUG_ARGUMENTS_IN_REVERSE_ORDER);
+        assertTrue("Should be debugging", subject.isDebugging());
+    }
+
+    @Test
+    public void givenPostJava5DebugArgumentsIsDebuggingShouldReturnTrue() {
+        DisableOnDebug subject = new DisableOnDebug(
+                new FailOnExecution(), POST_JAVA5_DEBUG_ARGUMENTS);
+        assertTrue("Should be debugging", subject.isDebugging());
+    }
+
+    @Test
+    public void givenArgumentsWithoutDebugFlagsIsDebuggingShouldReturnFalse() {
+        DisableOnDebug subject = new DisableOnDebug(
+                new FailOnExecution(), WITHOUT_DEBUG_ARGUMENTS);
+        Assert.assertFalse("Should not be debugging", subject.isDebugging());
+    }
+
+    @Test
+    public void whenRunWithPreJava5DebugArgumentsTestShouldFail() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(PreJava5DebugArgumentsTest.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("Test should not have failed", 0, result.getFailureCount());
+    }
+
+    @Test
+    public void whenRunWithPreJava5DebugArgumentsInReverseOrderTestShouldFail() {
+        JUnitCore core = new JUnitCore();
+        Result result = core
+                .run(PreJava5DebugArgumentsReversedTest.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("Test should not have failed", 0, result.getFailureCount());
+    }
+
+    @Test
+    public void whenRunWithPostJava5DebugArgumentsTestShouldFail() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(PostJava5DebugArgumentsTest.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("Test should not have failed", 0, result.getFailureCount());
+    }
+
+    @Test
+    public void whenRunWithoutDebugFlagsTestShouldPass() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(WithoutDebugArgumentsTest.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("Test should have failed", 1, result.getFailureCount());
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/ErrorCollectorTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/ErrorCollectorTest.java
new file mode 100644
index 0000000..385a146
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/ErrorCollectorTest.java
@@ -0,0 +1,327 @@
+package org.junit.rules;
+
+import org.hamcrest.Matcher;
+import org.hamcrest.Matchers;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+import java.util.concurrent.Callable;
+
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+import static org.junit.rules.EventCollector.*;
+
+@RunWith(Parameterized.class)
+public class ErrorCollectorTest {
+
+    @Parameters(name= "{0}")
+    public static Object[][] testsWithEventMatcher() {
+        return new Object[][]{
+                {
+                    AddSingleError.class,
+                        hasSingleFailureWithMessage("message")},
+                {
+                    AddTwoErrors.class,
+                        hasNumberOfFailures(2)},
+                {
+                    AddInternalAssumptionViolatedException.class,
+                        allOf(hasSingleFailure(), hasNoAssumptionFailure())},
+                {
+                    CheckMatcherThatDoesNotFailWithoutProvidedReason.class,
+                        everyTestRunSuccessful()},
+                {
+                    CheckMatcherThatDoesNotFailWithProvidedReason.class,
+                        everyTestRunSuccessful()},
+                {
+                    CheckMatcherThatFailsWithoutProvidedReason.class,
+                        hasSingleFailureWithMessage(Matchers.<String>allOf(
+                            containsString("Expected: is <4>"),
+                            containsString("but: was <3>")))},
+                {
+                    CheckMatcherThatFailsWithProvidedReason.class,
+                        hasSingleFailureWithMessage(Matchers.<String>allOf(
+                            containsString("reason"),
+                            containsString("Expected: is <4>"),
+                            containsString("but: was <3>")))},
+                {
+                    CheckTwoMatchersThatFail.class,
+                        hasNumberOfFailures(2)},
+                {
+                    CheckCallableThatThrowsAnException.class,
+                        hasSingleFailureWithMessage("first!")},
+                {
+                    CheckTwoCallablesThatThrowExceptions.class,
+                        hasNumberOfFailures(2)},
+                {
+                    CheckCallableThatThrowsInternalAssumptionViolatedException.class,
+                        allOf(hasSingleFailure(), hasNoAssumptionFailure())},
+                {
+                    CheckCallableWithFailingAssumption.class,
+                        allOf(hasSingleFailure(), hasNoAssumptionFailure())},
+                {
+                    CheckCallableThatDoesNotThrowAnException.class,
+                        everyTestRunSuccessful()},
+                {
+                    CheckRunnableThatThrowsExpectedTypeOfException.class,
+                        everyTestRunSuccessful()},
+                {
+                    CheckRunnableThatThrowsUnexpectedTypeOfException.class,
+                        hasSingleFailureWithMessage("unexpected exception type thrown; expected:<java.lang.IllegalArgumentException> but was:<java.lang.NullPointerException>")},
+                {
+                    CheckRunnableThatThrowsNoExceptionAlthoughOneIsExpected.class,
+                        hasSingleFailureWithMessage("expected java.lang.IllegalArgumentException to be thrown, but nothing was thrown")},
+                {
+                    ErrorCollectorNotCalledBySuccessfulTest.class,
+                        everyTestRunSuccessful()},
+                {
+                    ErrorCollectorNotCalledByFailingTest.class,
+                        hasSingleFailure()},
+        };
+    }
+
+    @Parameter(0)
+    public Class<?> classUnderTest;
+
+    @Parameter(1)
+    public Matcher<EventCollector> matcher;
+
+    @Test
+    public void runTestClassAndVerifyEvents() {
+        EventCollector collector = new EventCollector();
+        JUnitCore core = new JUnitCore();
+        core.addListener(collector);
+        core.run(classUnderTest);
+        assertThat(collector, matcher);
+    }
+
+    public static class AddSingleError {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.addError(new Throwable("message"));
+        }
+    }
+
+    public static class AddTwoErrors {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.addError(new Throwable("first thing went wrong"));
+            collector.addError(new Throwable("second thing went wrong"));
+        }
+    }
+
+    public static class AddInternalAssumptionViolatedException {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.addError(new AssumptionViolatedException("message"));
+        }
+    }
+
+    public static class CheckMatcherThatDoesNotFailWithProvidedReason {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkThat("dummy reason", 3, is(3));
+        }
+    }
+
+    public static class CheckMatcherThatDoesNotFailWithoutProvidedReason {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkThat(3, is(3));
+        }
+    }
+
+    public static class CheckMatcherThatFailsWithoutProvidedReason {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkThat(3, is(4));
+        }
+    }
+
+    public static class CheckMatcherThatFailsWithProvidedReason {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkThat("reason", 3, is(4));
+        }
+    }
+
+    public static class CheckTwoMatchersThatFail {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkThat(3, is(4));
+            collector.checkThat("reason", 7, is(8));
+        }
+    }
+
+    public static class CheckCallableThatThrowsAnException {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkSucceeds(new Callable<Object>() {
+                public Object call() throws Exception {
+                    throw new RuntimeException("first!");
+                }
+            });
+        }
+    }
+
+    public static class CheckTwoCallablesThatThrowExceptions {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkSucceeds(new Callable<Object>() {
+                public Object call() throws Exception {
+                    throw new RuntimeException("first!");
+                }
+            });
+            collector.checkSucceeds(new Callable<Integer>() {
+                public Integer call() throws Exception {
+                    throw new RuntimeException("second!");
+                }
+            });
+        }
+    }
+
+    public static class CheckCallableThatThrowsInternalAssumptionViolatedException {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkSucceeds(new Callable<Object>() {
+                public Object call() throws Exception {
+                    throw new AssumptionViolatedException("message");
+                }
+            });
+        }
+    }
+
+    public static class CheckCallableWithFailingAssumption {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkSucceeds(new Callable<Object>() {
+                public Object call() throws Exception {
+                    assumeTrue(false);
+                    return null;
+                }
+            });
+        }
+    }
+
+    public static class CheckCallableThatDoesNotThrowAnException {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            Object result = collector.checkSucceeds(new Callable<Object>() {
+                public Object call() throws Exception {
+                    return 3;
+                }
+            });
+            assertEquals(3, result);
+        }
+    }
+
+    public static class CheckRunnableThatThrowsExpectedTypeOfException {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkThrows(IllegalArgumentException.class, new ThrowingRunnable() {
+                public void run() throws Throwable {
+                    throw new IllegalArgumentException();
+                }
+            });
+        }
+    }
+
+    public static class CheckRunnableThatThrowsUnexpectedTypeOfException {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkThrows(IllegalArgumentException.class, new ThrowingRunnable() {
+                public void run() throws Throwable {
+                    throw new NullPointerException();
+                }
+            });
+        }
+    }
+
+    public static class CheckRunnableThatThrowsNoExceptionAlthoughOneIsExpected {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            collector.checkThrows(IllegalArgumentException.class, new ThrowingRunnable() {
+                public void run() throws Throwable {
+                }
+            });
+        }
+    }
+
+    public static class ErrorCollectorNotCalledBySuccessfulTest {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+        }
+    }
+
+    public static class ErrorCollectorNotCalledByFailingTest {
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Test
+        public void example() {
+            fail();
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/EventCollector.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/EventCollector.java
new file mode 100644
index 0000000..32c872e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/EventCollector.java
@@ -0,0 +1,191 @@
+package org.junit.rules;
+
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.core.IsEqual.equalTo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+
+public class EventCollector extends RunListener {
+    static Matcher<EventCollector> everyTestRunSuccessful() {
+        return allOf(hasNoFailure(), hasNoAssumptionFailure());
+    }
+
+    static Matcher<EventCollector> hasNumberOfFailures(
+            final int numberOfFailures) {
+        return new TypeSafeMatcher<EventCollector>() {
+            @Override
+            public boolean matchesSafely(EventCollector item) {
+                return item.fFailures.size() == numberOfFailures;
+            }
+
+            public void describeTo(org.hamcrest.Description description) {
+                description.appendText("has ");
+                description.appendValue(numberOfFailures);
+                description.appendText(" failures");
+            }
+
+            @Override
+            protected void describeMismatchSafely(EventCollector item,
+                    org.hamcrest.Description description) {
+                description.appendValue(item.fFailures.size());
+                description.appendText(" failures");
+            }
+        };
+    }
+
+    static Matcher<EventCollector> hasSingleFailure() {
+        return hasNumberOfFailures(1);
+    }
+
+    static Matcher<EventCollector> hasNoFailure() {
+        return hasNumberOfFailures(0);
+    }
+
+    private static Matcher<EventCollector> hasNumberOfAssumptionFailures(
+            final int numberOfFailures) {
+        return new TypeSafeMatcher<EventCollector>() {
+            @Override
+            public boolean matchesSafely(EventCollector item) {
+                return item.fAssumptionFailures.size() == numberOfFailures;
+            }
+
+            public void describeTo(org.hamcrest.Description description) {
+                description.appendText("has ");
+                description.appendValue(numberOfFailures);
+                description.appendText(" assumption failures");
+            }
+        };
+    }
+
+    static Matcher<EventCollector> hasSingleAssumptionFailure() {
+        return hasNumberOfAssumptionFailures(1);
+    }
+
+    static Matcher<EventCollector> hasNoAssumptionFailure() {
+        return hasNumberOfAssumptionFailures(0);
+    }
+
+    public static Matcher<EventCollector> hasSingleFailureWithMessage(String message) {
+        return hasSingleFailureWithMessage(equalTo(message));
+    }
+
+    static Matcher<EventCollector> hasSingleFailureWithMessage(
+            final Matcher<String> messageMatcher) {
+        return new TypeSafeMatcher<EventCollector>() {
+            @Override
+            public boolean matchesSafely(EventCollector item) {
+                return hasSingleFailure().matches(item)
+                        && messageMatcher.matches(item.fFailures.get(0)
+                        .getMessage());
+            }
+
+            public void describeTo(org.hamcrest.Description description) {
+                description.appendText("has single failure with message ");
+                messageMatcher.describeTo(description);
+            }
+
+            @Override
+            protected void describeMismatchSafely(EventCollector item,
+                    org.hamcrest.Description description) {
+                description.appendText("was ");
+                hasSingleFailure().describeMismatch(item, description);
+                description.appendText(": ");
+                boolean first= true;
+                for (Failure f : item.fFailures) {
+                    if (!first) {
+                        description.appendText(" ,");
+                    }
+                    description.appendText("'");
+                    description.appendText(f.getMessage());
+                    description.appendText("'");
+                    first= false;
+                }
+            }
+        };
+    }
+
+    static Matcher<EventCollector> failureIs(final Matcher<? super Throwable> exceptionMatcher) {
+        return new TypeSafeMatcher<EventCollector>() {
+            @Override
+            public boolean matchesSafely(EventCollector item) {
+                for (Failure f : item.fFailures) {
+                    return exceptionMatcher.matches(f.getException());
+                }
+                return false;
+            }
+
+            public void describeTo(org.hamcrest.Description description) {
+                description.appendText("failure is ");
+                exceptionMatcher.describeTo(description);
+            }
+        };
+    }
+
+    private final List<Description> fTestRunsStarted = new ArrayList<Description>();
+
+    private final List<Result> fTestRunsFinished = new ArrayList<Result>();
+
+    private final List<Description> fTestsStarted = new ArrayList<Description>();
+
+    private final List<Description> fTestsFinished = new ArrayList<Description>();
+
+    private final List<Failure> fFailures = new ArrayList<Failure>();
+
+    private final List<Failure> fAssumptionFailures = new ArrayList<Failure>();
+
+    private final List<Description> fTestsIgnored = new ArrayList<Description>();
+
+    @Override
+    public void testRunStarted(Description description) throws Exception {
+        fTestRunsStarted.add(description);
+    }
+
+    @Override
+    public void testRunFinished(Result result) throws Exception {
+        fTestRunsFinished.add(result);
+    }
+
+    @Override
+    public void testStarted(Description description) throws Exception {
+        fTestsStarted.add(description);
+    }
+
+    @Override
+    public void testFinished(Description description) throws Exception {
+        fTestsFinished.add(description);
+    }
+
+    @Override
+    public void testFailure(Failure failure) throws Exception {
+        fFailures.add(failure);
+    }
+
+    @Override
+    public void testAssumptionFailure(Failure failure) {
+        fAssumptionFailures.add(failure);
+    }
+
+    @Override
+    public void testIgnored(Description description) throws Exception {
+        fTestsIgnored.add(description);
+    }
+
+    @Override
+    public String toString() {
+        return fTestRunsStarted.size() + " test runs started, "
+            + fTestRunsFinished.size() + " test runs finished, "
+            + fTestsStarted.size() + " tests started, "
+            + fTestsFinished.size() + " tests finished, "
+            + fFailures.size() + " failures, "
+            + fAssumptionFailures.size() + " assumption failures, "
+            + fTestsIgnored.size() + " tests ignored";
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/ExpectedExceptionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/ExpectedExceptionTest.java
new file mode 100644
index 0000000..f9bf3f5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/ExpectedExceptionTest.java
@@ -0,0 +1,386 @@
+package org.junit.rules;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.any;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+import static org.junit.rules.ExpectedException.none;
+import static org.junit.rules.EventCollector.everyTestRunSuccessful;
+import static org.junit.rules.EventCollector.hasSingleAssumptionFailure;
+import static org.junit.rules.EventCollector.hasSingleFailure;
+import static org.junit.rules.EventCollector.hasSingleFailureWithMessage;
+
+import java.util.Collection;
+
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.Matcher;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ExpectedExceptionTest {
+    private static final String ARBITRARY_MESSAGE = "arbitrary message";
+
+    @Parameters(name= "{0}")
+    public static Collection<Object[]> testsWithEventMatcher() {
+        return asList(new Object[][]{
+                {EmptyTestExpectingNoException.class, everyTestRunSuccessful()},
+                {ThrowExceptionWithExpectedType.class,
+                        everyTestRunSuccessful()},
+                {ThrowExceptionWithExpectedPartOfMessage.class,
+                        everyTestRunSuccessful()},
+                {
+                        ThrowExceptionWithWrongType.class,
+                        hasSingleFailureWithMessage(startsWith("\nExpected: an instance of java.lang.NullPointerException"))},
+                {
+                        HasWrongMessage.class,
+                        hasSingleFailureWithMessage(startsWith("\nExpected: exception with message a string containing \"expectedMessage\"\n"
+                                + "     but: message was \"actualMessage\""))},
+                {
+                        ThrowNoExceptionButExpectExceptionWithType.class,
+                        hasSingleFailureWithMessage("Expected test to throw an instance of java.lang.NullPointerException")},
+                {WronglyExpectsExceptionMessage.class, hasSingleFailure()},
+                {ExpectsSubstring.class, everyTestRunSuccessful()},
+                {
+                        ExpectsSubstringNullMessage.class,
+                        hasSingleFailureWithMessage(startsWith("\nExpected: exception with message a string containing \"anything!\""))},
+                {ExpectsMessageMatcher.class, everyTestRunSuccessful()},
+                {
+                        ExpectedMessageMatcherFails.class,
+                        hasSingleFailureWithMessage(startsWith("\nExpected: exception with message \"Wrong start\""))},
+                {ExpectsMatcher.class, everyTestRunSuccessful()},
+                {ExpectAssertionErrorWhichIsNotThrown.class, hasSingleFailure()},
+                {FailedAssumptionAndExpectException.class,
+                        hasSingleAssumptionFailure()},
+                {FailBeforeExpectingException.class,
+                        hasSingleFailureWithMessage(ARBITRARY_MESSAGE)},
+                {
+                        ExpectsMultipleMatchers.class,
+                        hasSingleFailureWithMessage(startsWith("\nExpected: (an instance of java.lang.IllegalArgumentException and exception with message a string containing \"Ack!\")"))},
+                {ThrowExceptionWithMatchingCause.class, everyTestRunSuccessful()},
+                {ThrowExpectedNullCause.class, everyTestRunSuccessful()},
+                {
+                        ThrowUnexpectedCause.class,
+                        hasSingleFailureWithMessage(CoreMatchers.<String>allOf(
+                                startsWith("\nExpected: ("),
+                                containsString("exception with cause is <java.lang.NullPointerException: expected cause>"),
+                                containsString("cause was <java.lang.NullPointerException: an unexpected cause>"),
+                                containsString("Stacktrace was: java.lang.IllegalArgumentException: Ack!"),
+                                containsString("Caused by: java.lang.NullPointerException: an unexpected cause")))},
+                {
+                        UseNoCustomMessage.class,
+                        hasSingleFailureWithMessage("Expected test to throw an instance of java.lang.IllegalArgumentException") },
+                {
+                        UseCustomMessageWithoutPlaceHolder.class,
+                        hasSingleFailureWithMessage(ARBITRARY_MESSAGE) },
+                {
+                        UseCustomMessageWithPlaceHolder.class,
+                        hasSingleFailureWithMessage(ARBITRARY_MESSAGE
+                                + " - an instance of java.lang.IllegalArgumentException") },
+                {
+                        ErrorCollectorShouldFailAlthoughExpectedExceptionDoesNot.class,
+                        hasSingleFailureWithMessage(ARBITRARY_MESSAGE) }
+        });
+    }
+
+    private final Class<?> classUnderTest;
+
+    private final Matcher<EventCollector> matcher;
+
+    public ExpectedExceptionTest(Class<?> classUnderTest,
+            Matcher<EventCollector> matcher) {
+        this.classUnderTest = classUnderTest;
+        this.matcher = matcher;
+    }
+
+    @Test
+    public void runTestAndVerifyResult() {
+        EventCollector collector = new EventCollector();
+        JUnitCore core = new JUnitCore();
+        core.addListener(collector);
+        core.run(classUnderTest);
+        assertThat(collector, matcher);
+    }
+
+    public static class EmptyTestExpectingNoException {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwsNothing() {
+        }
+    }
+
+    public static class ThrowExceptionWithExpectedType {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwsNullPointerException() {
+            thrown.expect(NullPointerException.class);
+            throw new NullPointerException();
+        }
+    }
+
+    public static class ThrowExceptionWithExpectedPartOfMessage {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwsNullPointerExceptionWithMessage() {
+            thrown.expect(NullPointerException.class);
+            thrown.expectMessage(ARBITRARY_MESSAGE);
+            throw new NullPointerException(ARBITRARY_MESSAGE + "something else");
+        }
+    }
+
+    public static class ThrowExceptionWithWrongType {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwsNullPointerException() {
+            thrown.expect(NullPointerException.class);
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public static class HasWrongMessage {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwsNullPointerException() {
+            thrown.expectMessage("expectedMessage");
+            throw new IllegalArgumentException("actualMessage");
+        }
+    }
+
+    public static class ThrowNoExceptionButExpectExceptionWithType {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void doesntThrowNullPointerException() {
+            thrown.expect(NullPointerException.class);
+        }
+    }
+
+    public static class WronglyExpectsExceptionMessage {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void doesntThrowAnything() {
+            thrown.expectMessage("anything!");
+        }
+    }
+
+    public static class ExpectsSubstring {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwsMore() {
+            thrown.expectMessage("anything!");
+            throw new NullPointerException(
+                    "This could throw anything! (as long as it has the right substring)");
+        }
+    }
+
+    public static class ExpectsSubstringNullMessage {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwsMore() {
+            thrown.expectMessage("anything!");
+            throw new NullPointerException();
+        }
+    }
+
+    public static class ExpectsMessageMatcher {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwsMore() {
+            thrown.expectMessage(startsWith(ARBITRARY_MESSAGE));
+            throw new NullPointerException(ARBITRARY_MESSAGE + "!");
+        }
+    }
+
+    public static class ExpectedMessageMatcherFails {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwsMore() {
+            thrown.expectMessage(equalTo("Wrong start"));
+            throw new NullPointerException("Back!");
+        }
+    }
+
+    public static class ExpectsMatcher {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwsMore() {
+            thrown.expect(any(Exception.class));
+            throw new NullPointerException("Ack!");
+        }
+    }
+
+    public static class ExpectsMultipleMatchers {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwsMore() {
+            thrown.expect(IllegalArgumentException.class);
+            thrown.expectMessage("Ack!");
+            throw new NullPointerException("Ack!");
+        }
+    }
+
+    //https://github.com/junit-team/junit4/pull/583
+    public static class ExpectAssertionErrorWhichIsNotThrown {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void fails() {
+            thrown.expect(AssertionError.class);
+        }
+    }
+
+    public static class FailBeforeExpectingException {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void fails() {
+            fail(ARBITRARY_MESSAGE);
+            thrown.expect(IllegalArgumentException.class);
+        }
+    }
+
+    public static class FailedAssumptionAndExpectException {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void failedAssumption() {
+            assumeTrue(false);
+            thrown.expect(NullPointerException.class);
+        }
+    }
+
+    public static class ThrowExceptionWithMatchingCause {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwExceptionWithMatchingCause() {
+            NullPointerException expectedCause = new NullPointerException("expected cause");
+
+            thrown.expect(IllegalArgumentException.class);
+            thrown.expectMessage("Ack!");
+            thrown.expectCause(is(expectedCause));
+
+            throw new IllegalArgumentException("Ack!", expectedCause);
+        }
+    }
+
+    public static class ThrowExpectedNullCause {
+        @Rule
+        public ExpectedException thrown = none();
+
+        @Test
+        public void throwExpectedNullCause() {
+            thrown.expect(IllegalArgumentException.class);
+            thrown.expectMessage("Ack!");
+            thrown.expectCause(nullValue(Throwable.class));
+
+            throw new IllegalArgumentException("Ack!");
+        }
+    }
+
+    public static class ThrowUnexpectedCause {
+
+        @Rule
+        public ExpectedException thrown = ExpectedException.none();
+
+        @Test
+        public void throwWithCause() {
+            thrown.expect(IllegalArgumentException.class);
+            thrown.expectMessage("Ack!");
+            thrown.expectCause(is(new NullPointerException("expected cause")));
+
+            throw new IllegalArgumentException("Ack!", new NullPointerException("an unexpected cause"));
+        }
+    }
+    
+    public static class UseNoCustomMessage {
+
+        @Rule
+        public ExpectedException thrown= ExpectedException.none();
+
+        @Test
+        public void noThrow() {
+            thrown.expect(IllegalArgumentException.class);
+        }
+    }
+
+    public static class UseCustomMessageWithPlaceHolder {
+
+        @Rule
+        public ExpectedException thrown = ExpectedException.none();
+
+        @Test
+        public void noThrow() {
+            thrown.expect(IllegalArgumentException.class);
+            thrown.reportMissingExceptionWithMessage(ARBITRARY_MESSAGE
+                    + " - %s");
+        }
+    }
+
+    public static class UseCustomMessageWithoutPlaceHolder {
+
+        @Rule
+        public ExpectedException thrown= ExpectedException.none();
+
+        @Test
+        public void noThrow() {
+            thrown.expect(IllegalArgumentException.class);
+            thrown.reportMissingExceptionWithMessage(ARBITRARY_MESSAGE);
+        }
+    }
+
+    public static class ErrorCollectorShouldFailAlthoughExpectedExceptionDoesNot {
+
+        @Rule
+        public ErrorCollector collector = new ErrorCollector();
+
+        @Rule(order = Integer.MAX_VALUE)
+        public ExpectedException thrown = ExpectedException.none();
+
+        @Test
+        public void test() {
+            collector.addError(new AssertionError(ARBITRARY_MESSAGE));
+            thrown.expect(Exception.class);
+            throw new RuntimeException();
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/ExternalResourceRuleTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/ExternalResourceRuleTest.java
new file mode 100644
index 0000000..ba4302e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/ExternalResourceRuleTest.java
@@ -0,0 +1,168 @@
+package org.junit.rules;
+
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.sameInstance;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+import static org.junit.internal.matchers.ThrowableCauseMatcher.hasCause;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.Matcher;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.TestCouldNotBeSkippedException;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.internal.runners.statements.Fail;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runners.model.MultipleFailureException;
+import org.junit.runners.model.Statement;
+
+public class ExternalResourceRuleTest {
+    private static String callSequence;
+
+    public static class UsesExternalResource {
+        @Rule
+        public ExternalResource resource = new ExternalResource() {
+            @Override
+            protected void before() throws Throwable {
+                callSequence += "before ";
+            }
+
+            @Override
+            protected void after() {
+                callSequence += "after ";
+            }
+        };
+
+        @Test
+        public void testFoo() {
+            callSequence += "test ";
+        }
+    }
+
+    @Test
+    public void externalResourceGeneratesCorrectSequence() {
+        callSequence = "";
+        assertThat(testResult(UsesExternalResource.class), isSuccessful());
+        assertEquals("before test after ", callSequence);
+    }
+
+    @Test
+    public void shouldThrowMultipleFailureExceptionWhenTestFailsAndClosingResourceFails() throws Throwable {
+        // given
+        ExternalResource resourceRule = new ExternalResource() {
+            @Override
+            protected void after() {
+                throw new RuntimeException("simulating resource tear down failure");
+            }
+        };
+        Statement failingTest = new Fail(new RuntimeException("simulated test failure"));
+        Description dummyDescription = Description.createTestDescription(
+                "dummy test class name", "dummy test name");
+
+        try {
+            resourceRule.apply(failingTest, dummyDescription).evaluate();
+            fail("ExternalResource should throw");
+        } catch (MultipleFailureException e) {
+            assertThat(e.getMessage(), allOf(
+                    containsString("simulated test failure"),
+                    containsString("simulating resource tear down failure")
+            ));
+        }
+    }
+
+    public static class TestFailsAndTwoClosingResourcesFail {
+        @Rule
+        public ExternalResource resourceRule1 = new ExternalResource() {
+            @Override
+            protected void after() {
+                throw new RuntimeException("simulating resource1 tear down failure");
+            }
+        };
+
+        @Rule
+        public ExternalResource resourceRule2 = new ExternalResource() {
+            @Override
+            protected void after() {
+                throw new RuntimeException("simulating resource2 tear down failure");
+            }
+        };
+
+        @Test
+        public void failingTest() {
+            throw new RuntimeException("simulated test failure");
+        }
+    }
+
+    @Test
+    public void shouldThrowMultipleFailureExceptionWhenTestFailsAndTwoClosingResourcesFail() {
+        Result result = JUnitCore.runClasses(TestFailsAndTwoClosingResourcesFail.class);
+        assertEquals(3, result.getFailures().size());
+        List<String> messages = new ArrayList<String>();
+        for (Failure failure : result.getFailures()) {
+            messages.add(failure.getMessage());
+        }
+        assertThat(messages, CoreMatchers.hasItems(
+                "simulated test failure",
+                "simulating resource1 tear down failure",
+                "simulating resource2 tear down failure"
+        ));
+    }
+
+    @Test
+    public void shouldWrapAssumptionFailuresWhenClosingResourceFails() throws Throwable {
+        // given
+        final AtomicReference<Throwable> externalResourceException = new AtomicReference<Throwable>();
+        ExternalResource resourceRule = new ExternalResource() {
+            @Override
+            protected void after() {
+                RuntimeException runtimeException = new RuntimeException("simulating resource tear down failure");
+                externalResourceException.set(runtimeException);
+                throw runtimeException;
+            }
+        };
+        final AtomicReference<Throwable> assumptionViolatedException = new AtomicReference<Throwable>();
+        Statement skippedTest = new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                AssumptionViolatedException assumptionFailure = new AssumptionViolatedException("skip it");
+                assumptionViolatedException.set(assumptionFailure);
+                throw assumptionFailure;
+            }
+        };
+        Description dummyDescription = Description.createTestDescription(
+                "dummy test class name", "dummy test name");
+
+        try {
+            resourceRule.apply(skippedTest, dummyDescription).evaluate();
+            fail("ExternalResource should throw");
+        } catch (MultipleFailureException e) {
+            assertThat(e.getFailures(), hasItems(
+                    instanceOf(TestCouldNotBeSkippedException.class),
+                    sameInstance(externalResourceException.get())
+            ));
+            assertThat(e.getFailures(), hasItems(
+                    hasCause(sameInstance(assumptionViolatedException.get())),
+                    sameInstance(externalResourceException.get())
+            ));
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private Matcher<? super List<Throwable>> hasItems(
+            Matcher<? super Throwable> one, Matcher<? super Throwable> two) {
+        return CoreMatchers.hasItems(one, two);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingMethodRule.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingMethodRule.java
new file mode 100644
index 0000000..9df2d23
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingMethodRule.java
@@ -0,0 +1,18 @@
+package org.junit.rules;
+
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+class LoggingMethodRule implements MethodRule {
+    private final StringBuilder log;
+    private final String name;
+
+    LoggingMethodRule(StringBuilder log, String name) {
+        this.name = name;
+        this.log = log;
+    }
+
+    public Statement apply(Statement base, FrameworkMethod method, Object target) {
+        return new LoggingStatement(base, log, name);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingStatement.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingStatement.java
new file mode 100644
index 0000000..af36239
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingStatement.java
@@ -0,0 +1,24 @@
+package org.junit.rules;
+
+import org.junit.runners.model.Statement;
+
+class LoggingStatement extends Statement {
+    private final Statement base;
+    private final StringBuilder log;
+    private final String name;
+
+    LoggingStatement(Statement base, StringBuilder log, String name) {
+        this.base = base;
+        this.log = log;
+        this.name = name;
+    }
+
+    public void evaluate() throws Throwable {
+        log.append(" ").append(name).append(".begin");
+        try {
+            base.evaluate();
+        } finally {
+            log.append(" ").append(name).append(".end");
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingTestRule.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingTestRule.java
new file mode 100644
index 0000000..08792f2
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingTestRule.java
@@ -0,0 +1,18 @@
+package org.junit.rules;
+
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+class LoggingTestRule implements TestRule {
+    private final StringBuilder log;
+    private final String name;
+
+    LoggingTestRule(StringBuilder log, String name) {
+        this.name = name;
+        this.log = log;
+    }
+
+    public Statement apply(Statement base, Description description) {
+        return new LoggingStatement(base, log, name);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingTestWatcher.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingTestWatcher.java
new file mode 100644
index 0000000..44d32a3
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/LoggingTestWatcher.java
@@ -0,0 +1,42 @@
+package org.junit.rules;
+
+import org.junit.AssumptionViolatedException;
+import org.junit.runner.Description;
+
+class LoggingTestWatcher extends TestWatcher {
+    private final StringBuilder log;
+
+    LoggingTestWatcher(StringBuilder log) {
+        this.log = log;
+    }
+
+    @Override
+    protected void succeeded(Description description) {
+        log.append("succeeded ");
+    }
+
+    @Override
+    protected void failed(Throwable e, Description description) {
+        log.append("failed ");
+    }
+
+    @Override
+    protected void skipped(AssumptionViolatedException e, Description description) {
+        log.append("skipped ");
+    }
+
+    @Override
+    protected void skipped(org.junit.internal.AssumptionViolatedException e, Description description) {
+        log.append("deprecated skipped ");
+    }
+
+    @Override
+    protected void starting(Description description) {
+        log.append("starting ");
+    }
+
+    @Override
+    protected void finished(Description description) {
+        log.append("finished ");
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/MethodRulesTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/MethodRulesTest.java
new file mode 100644
index 0000000..6c59f7e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/MethodRulesTest.java
@@ -0,0 +1,420 @@
+package org.junit.rules;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.failureCountIs;
+import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+@SuppressWarnings("deprecation")
+public class MethodRulesTest {
+    private static boolean ruleWasEvaluated;
+
+    private static class TestMethodRule implements MethodRule {
+
+        public Statement apply(final Statement base, FrameworkMethod method, Object target) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    ruleWasEvaluated = true;
+                    base.evaluate();
+                }
+            };
+        }
+    }
+
+    public static class ExampleTest {
+        @Rule
+        public MethodRule example = new TestMethodRule();
+
+        @Test
+        public void nothing() {
+        }
+    }
+
+    abstract static class NonPublicExampleTest {
+        @Rule
+        public MethodRule example = new TestMethodRule();
+
+        @Test
+        public void nothing() {
+        }
+    }
+
+    @Test
+    public void ruleIsIntroducedAndEvaluated() {
+        ruleWasEvaluated = false;
+        assertThat(testResult(ExampleTest.class), isSuccessful());
+        assertTrue(ruleWasEvaluated);
+    }
+
+    public static class SonOfExampleTest extends ExampleTest {
+
+    }
+
+    @Test
+    public void ruleIsIntroducedAndEvaluatedOnSubclass() {
+        ruleWasEvaluated = false;
+        assertThat(testResult(SonOfExampleTest.class), isSuccessful());
+        assertTrue(ruleWasEvaluated);
+    }
+
+    public static class SonOfNonPublicExampleTest extends NonPublicExampleTest {
+
+    }
+
+    @Test
+    public void ruleIsIntroducedAndEvaluatedOnSubclassOfNonPublicClass() {
+        ruleWasEvaluated = false;
+        assertThat(testResult(SonOfNonPublicExampleTest.class), isSuccessful());
+        assertTrue(ruleWasEvaluated);
+    }
+
+    private static int runCount;
+
+    private static class Increment implements MethodRule {
+        public Statement apply(final Statement base,
+                FrameworkMethod method, Object target) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    runCount++;
+                    base.evaluate();
+                }
+            };
+        }
+    }
+    
+    public static class MultipleRuleTest {
+
+        @Rule
+        public MethodRule incrementor1 = new Increment();
+
+        @Rule
+        public MethodRule incrementor2 = new Increment();
+
+        @Test
+        public void nothing() {
+
+        }
+    }
+
+    @Test
+    public void multipleRulesAreRun() {
+        runCount = 0;
+        assertThat(testResult(MultipleRuleTest.class), isSuccessful());
+        assertEquals(2, runCount);
+    }
+
+    public static class NoRulesTest {
+        public int x;
+
+        @Test
+        public void nothing() {
+
+        }
+    }
+
+    @Test
+    public void ignoreNonRules() {
+        assertThat(testResult(NoRulesTest.class), isSuccessful());
+    }
+
+    private static String log;
+
+    public static class OnFailureTest {
+        @Rule
+        public MethodRule watchman = new TestWatchman() {
+            @Override
+            public void failed(Throwable e, FrameworkMethod method) {
+                log += method.getName() + " " + e.getClass().getSimpleName();
+            }
+        };
+
+        @Test
+        public void nothing() {
+            fail();
+        }
+    }
+
+    @Test
+    public void onFailure() {
+        log = "";
+        assertThat(testResult(OnFailureTest.class), failureCountIs(1));
+        assertEquals("nothing AssertionError", log);
+    }
+
+    public static class WatchmanTest {
+        private static String watchedLog;
+
+        @Rule
+        public MethodRule watchman = new TestWatchman() {
+            @Override
+            public void failed(Throwable e, FrameworkMethod method) {
+                watchedLog += method.getName() + " "
+                        + e.getClass().getSimpleName() + "\n";
+            }
+
+            @Override
+            public void succeeded(FrameworkMethod method) {
+                watchedLog += method.getName() + " " + "success!\n";
+            }
+        };
+
+        @Test
+        public void fails() {
+            fail();
+        }
+
+        @Test
+        public void succeeds() {
+        }
+    }
+
+    @Test
+    public void succeeded() {
+        WatchmanTest.watchedLog = "";
+        assertThat(testResult(WatchmanTest.class), failureCountIs(1));
+        assertThat(WatchmanTest.watchedLog, containsString("fails AssertionError"));
+        assertThat(WatchmanTest.watchedLog, containsString("succeeds success!"));
+    }
+
+    public static class BeforesAndAfters {
+        private static String watchedLog;
+
+        @Before
+        public void before() {
+            watchedLog += "before ";
+        }
+
+        @Rule
+        public MethodRule watchman = new TestWatchman() {
+            @Override
+            public void starting(FrameworkMethod method) {
+                watchedLog += "starting ";
+            }
+
+            @Override
+            public void finished(FrameworkMethod method) {
+                watchedLog += "finished ";
+            }
+
+            @Override
+            public void succeeded(FrameworkMethod method) {
+                watchedLog += "succeeded ";
+            }
+        };
+
+        @After
+        public void after() {
+            watchedLog += "after ";
+        }
+
+        @Test
+        public void succeeds() {
+            watchedLog += "test ";
+        }
+    }
+
+    @Test
+    public void beforesAndAfters() {
+        BeforesAndAfters.watchedLog = "";
+        assertThat(testResult(BeforesAndAfters.class), isSuccessful());
+        assertThat(BeforesAndAfters.watchedLog, is("starting before test after succeeded finished "));
+    }
+
+    public static class WrongTypedField {
+        @Rule
+        public int x = 5;
+
+        @Test
+        public void foo() {
+        }
+    }
+
+    @Test
+    public void validateWrongTypedField() {
+        assertThat(testResult(WrongTypedField.class),
+                hasSingleFailureContaining("must implement MethodRule"));
+    }
+
+    public static class SonOfWrongTypedField extends WrongTypedField {
+
+    }
+
+    @Test
+    public void validateWrongTypedFieldInSuperclass() {
+        assertThat(testResult(SonOfWrongTypedField.class),
+                hasSingleFailureContaining("must implement MethodRule"));
+    }
+
+    public static class PrivateRule {
+        @Rule
+        private TestRule rule = new TestName();
+
+        @Test
+        public void foo() {
+        }
+    }
+
+    @Test
+    public void validatePrivateRule() {
+        assertThat(testResult(PrivateRule.class),
+                hasSingleFailureContaining("must be public"));
+    }
+
+    public static class CustomTestName implements TestRule {
+        public String name = null;
+
+        public Statement apply(final Statement base, final Description description) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    name = description.getMethodName();
+                    base.evaluate();
+                }
+            };
+        }
+    }
+
+    public static class UsesCustomMethodRule {
+        @Rule
+        public CustomTestName counter = new CustomTestName();
+
+        @Test
+        public void foo() {
+            assertEquals("foo", counter.name);
+        }
+    }
+
+    @Test
+    public void useCustomMethodRule() {
+        assertThat(testResult(UsesCustomMethodRule.class), isSuccessful());
+    }
+    
+    public static class HasMethodReturningMethodRule {
+        private MethodRule methodRule = new MethodRule() {
+            public Statement apply(final Statement base, FrameworkMethod method, Object target) {
+                return new Statement() {
+                    
+                    @Override
+                    public void evaluate() throws Throwable {
+                        ruleWasEvaluated = true;
+                        base.evaluate();
+                    }
+                };
+            }
+        };
+        
+        @Rule
+        public MethodRule methodRule() {
+            return methodRule;
+        }
+        
+        @Test
+        public void doNothing() {
+            
+        }
+    }
+
+    /**
+     * If there are any public methods annotated with @Rule returning a {@link MethodRule}
+     * then it should also be run.
+     * 
+     * <p>This case has been added with 
+     * <a href="https://github.com/junit-team/junit4/issues/589">Issue #589</a> - 
+     * Support @Rule for methods works only for TestRule but not for MethodRule
+     */
+    @Test
+    public void runsMethodRuleThatIsReturnedByMethod() {
+        ruleWasEvaluated = false;
+        assertThat(testResult(HasMethodReturningMethodRule.class), isSuccessful());
+        assertTrue(ruleWasEvaluated);
+    }
+    
+    public static class HasMultipleMethodsReturningMethodRule {
+        @Rule
+        public Increment methodRule1() {
+            return new Increment();
+        }
+        
+        @Rule
+        public Increment methodRule2() {
+            return new Increment();
+        }
+        
+        @Test
+        public void doNothing() {
+            
+        }
+    }
+
+    /**
+     * If there are multiple public methods annotated with @Rule returning a {@link MethodRule}
+     * then all the rules returned should be run.
+     * 
+     * <p>This case has been added with 
+     * <a href="https://github.com/junit-team/junit4/issues/589">Issue #589</a> - 
+     * Support @Rule for methods works only for TestRule but not for MethodRule
+     */
+    @Test
+    public void runsAllMethodRulesThatAreReturnedByMethods() {
+        runCount = 0;
+        assertThat(testResult(HasMultipleMethodsReturningMethodRule.class), isSuccessful());
+        assertEquals(2, runCount);
+    }
+    
+    
+    public static class CallsMethodReturningRuleOnlyOnce {
+        int callCount = 0;
+        
+        private static class Dummy implements MethodRule {
+            public Statement apply(final Statement base, FrameworkMethod method, Object target) {
+                return new Statement() {
+                    
+                    @Override
+                    public void evaluate() throws Throwable {
+                        base.evaluate();
+                    }
+                };
+            }
+        }
+       
+        
+        @Rule
+        public MethodRule methodRule() {
+            callCount++;
+            return new Dummy();
+        }
+        
+        @Test
+        public void doNothing() {
+            assertEquals(1, callCount);
+        }
+    }
+
+    /**
+     * If there are any public methods annotated with @Rule returning a {@link MethodRule}
+     * then method should be called only once.
+     * 
+     * <p>This case has been added with 
+     * <a href="https://github.com/junit-team/junit4/issues/589">Issue #589</a> - 
+     * Support @Rule for methods works only for TestRule but not for MethodRule
+     */
+    @Test
+    public void callsMethodReturningRuleOnlyOnce() {
+        assertThat(testResult(CallsMethodReturningRuleOnlyOnce.class), isSuccessful());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/NameRulesTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/NameRulesTest.java
new file mode 100644
index 0000000..9ae45ff
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/NameRulesTest.java
@@ -0,0 +1,50 @@
+package org.junit.rules;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+
+@RunWith(Enclosed.class)
+public class NameRulesTest {
+    public static class TestNames {
+        @Rule
+        public TestName name = new TestName();
+
+        @Test
+        public void testA() {
+            assertEquals("testA", name.getMethodName());
+        }
+
+        @Test
+        public void testB() {
+            assertEquals("testB", name.getMethodName());
+        }
+    }
+
+    public static class BeforeAndAfterTest {
+        @Rule
+        public TestName name = new TestName();
+
+        private final String expectedName = "x";
+
+        @Before
+        public void setUp() {
+            assertEquals(expectedName, name.getMethodName());
+        }
+
+        @Test
+        public void x() {
+            assertEquals(expectedName, name.getMethodName());
+        }
+
+        @After
+        public void tearDown() {
+            assertEquals(expectedName, name.getMethodName());
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/RuleChainTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/RuleChainTest.java
new file mode 100644
index 0000000..54daf8d
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/RuleChainTest.java
@@ -0,0 +1,94 @@
+package org.junit.rules;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.rules.RuleChain.outerRule;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.internal.Throwables;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+
+public class RuleChainTest {
+    private static final List<String> LOG = new ArrayList<String>();
+
+    private static class LoggingRule extends TestWatcher {
+        private final String label;
+
+        public LoggingRule(String label) {
+            this.label = label;
+        }
+
+        @Override
+        protected void starting(Description description) {
+            LOG.add("starting " + label);
+        }
+
+        @Override
+        protected void finished(Description description) {
+            LOG.add("finished " + label);
+        }
+    }
+
+    public static class UseRuleChain {
+        @Rule
+        public final RuleChain chain = outerRule(new LoggingRule("outer rule"))
+                .around(new LoggingRule("middle rule")).around(
+                        new LoggingRule("inner rule"));
+
+        @Test
+        public void example() {
+            assertTrue(true);
+        }
+    }
+
+    @Test
+    public void executeRulesInCorrectOrder() throws Exception {
+        testResult(UseRuleChain.class);
+        List<String> expectedLog = asList("starting outer rule",
+                "starting middle rule", "starting inner rule",
+                "finished inner rule", "finished middle rule",
+                "finished outer rule");
+        assertEquals(expectedLog, LOG);
+    }
+
+    @Test
+    public void aroundShouldNotAllowNullRules() {
+        RuleChain chain = RuleChain.emptyRuleChain();
+        try {
+            chain.around(null);
+            fail("around() should not allow null rules");
+        } catch (NullPointerException e) {
+            assertThat(e.getMessage(), equalTo("The enclosed rule must not be null"));
+        }
+    }
+
+    public static class RuleChainWithNullRules {
+        @Rule
+        public final RuleChain chain = outerRule(new LoggingRule("outer rule"))
+                .around(null);
+
+        @Test
+        public void example() {}
+    }
+
+    @Test
+    public void whenRuleChainHasNullRuleTheStacktraceShouldPointToIt() {
+        Result result = JUnitCore.runClasses(RuleChainWithNullRules.class);
+
+        assertThat(result.getFailures().size(), equalTo(1));
+        String stacktrace = Throwables.getStacktrace(result.getFailures().get(0).getException());
+        assertThat(stacktrace, containsString("\tat org.junit.rules.RuleChainTest$RuleChainWithNullRules.<init>(RuleChainTest.java:"));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/RuleMemberValidatorTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/RuleMemberValidatorTest.java
new file mode 100644
index 0000000..01465a6
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/RuleMemberValidatorTest.java
@@ -0,0 +1,356 @@
+package org.junit.rules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.internal.runners.rules.RuleMemberValidator.CLASS_RULE_METHOD_VALIDATOR;
+import static org.junit.internal.runners.rules.RuleMemberValidator.CLASS_RULE_VALIDATOR;
+import static org.junit.internal.runners.rules.RuleMemberValidator.RULE_METHOD_VALIDATOR;
+import static org.junit.internal.runners.rules.RuleMemberValidator.RULE_VALIDATOR;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+import org.junit.runners.model.TestClass;
+
+public class RuleMemberValidatorTest {
+    private final List<Throwable> errors = new ArrayList<Throwable>();
+
+    @Test
+    public void rejectProtectedClassRule() {
+        TestClass target = new TestClass(TestWithProtectedClassRule.class);
+        CLASS_RULE_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @ClassRule 'temporaryFolder' must be public.");
+    }
+
+    public static class TestWithProtectedClassRule {
+        @ClassRule
+        protected static TestRule temporaryFolder = new TemporaryFolder();
+    }
+
+    @Test
+    public void rejectNonStaticClassRule() {
+        TestClass target = new TestClass(TestWithNonStaticClassRule.class);
+        CLASS_RULE_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @ClassRule 'temporaryFolder' must be static.");
+    }
+
+    public static class TestWithNonStaticClassRule {
+        @ClassRule
+        public TestRule temporaryFolder = new TemporaryFolder();
+    }
+
+    @Test
+    public void acceptStaticTestRuleThatIsAlsoClassRule() {
+        TestClass target = new TestClass(TestWithStaticClassAndTestRule.class);
+        CLASS_RULE_VALIDATOR.validate(target, errors);
+        assertNumberOfErrors(0);
+    }
+
+    public static class TestWithStaticClassAndTestRule {
+        @ClassRule
+        @Rule
+        public static TestRule temporaryFolder = new TemporaryFolder();
+    }
+
+    @Test
+    public void rejectClassRuleInNonPublicClass() {
+        TestClass target = new TestClass(NonPublicTestWithClassRule.class);
+        CLASS_RULE_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @ClassRule 'temporaryFolder' must be declared in a public class.");
+    }
+
+    static class NonPublicTestWithClassRule {
+        @ClassRule
+        public static TestRule temporaryFolder = new TemporaryFolder();
+    }
+    
+    /**
+     * If there is any property annotated with @ClassRule then it must implement
+     * {@link TestRule}
+     * 
+     * <p>This case has been added with 
+     * <a href="https://github.com/junit-team/junit4/issues/1019">Issue #1019</a>
+     */
+    @Test
+    public void rejectClassRuleThatIsImplementationOfMethodRule() {
+        TestClass target = new TestClass(TestWithClassRuleIsImplementationOfMethodRule.class);
+        CLASS_RULE_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @ClassRule 'classRule' must implement TestRule.");
+    }
+    
+    public static class TestWithClassRuleIsImplementationOfMethodRule {
+        @ClassRule
+        public static MethodRule classRule = new MethodRule() {
+            
+            public Statement apply(Statement base, FrameworkMethod method, Object target) {
+                return base;
+            }
+        };
+    }
+
+    /**
+     * If there is any method annotated with @ClassRule then it must return an 
+     * implementation of {@link TestRule}
+     * 
+     * <p>This case has been added with 
+     * <a href="https://github.com/junit-team/junit4/issues/1019">Issue #1019</a>
+     */
+    @Test
+    public void rejectClassRuleThatReturnsImplementationOfMethodRule() {
+        TestClass target = new TestClass(TestWithClassRuleMethodThatReturnsMethodRule.class);
+        CLASS_RULE_METHOD_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @ClassRule 'methodRule' must return an implementation of TestRule.");
+    }
+
+    public static class TestWithClassRuleMethodThatReturnsMethodRule {
+        @ClassRule
+        public static MethodRule methodRule() {
+            return new MethodRule() {
+                
+                public Statement apply(Statement base, FrameworkMethod method, Object target) {
+                    return base;
+                }
+            };
+        }
+    }
+    
+    /**
+     * If there is any property annotated with @ClassRule then it must implement
+     * {@link TestRule}
+     * 
+     * <p>This case has been added with 
+     * <a href="https://github.com/junit-team/junit4/issues/1019">Issue #1019</a>
+     */
+    @Test
+    public void rejectClassRuleIsAnArbitraryObject() throws Exception {
+        TestClass target = new TestClass(TestWithClassRuleIsAnArbitraryObject.class);
+        CLASS_RULE_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @ClassRule 'arbitraryObject' must implement TestRule.");
+    }
+
+    public static class TestWithClassRuleIsAnArbitraryObject {
+        @ClassRule
+        public static Object arbitraryObject = 1;
+    }
+    
+    /**
+     * If there is any method annotated with @ClassRule then it must return an 
+     * implementation of {@link TestRule}
+     * 
+     * <p>This case has been added with 
+     * <a href="https://github.com/junit-team/junit4/issues/1019">Issue #1019</a> 
+     */
+    @Test
+    public void rejectClassRuleMethodReturnsAnArbitraryObject() throws Exception {
+        TestClass target = new TestClass(TestWithClassRuleMethodReturnsAnArbitraryObject.class);
+        CLASS_RULE_METHOD_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @ClassRule 'arbitraryObject' must return an implementation of TestRule.");
+    }
+
+    public static class TestWithClassRuleMethodReturnsAnArbitraryObject {
+        @ClassRule
+        public static Object arbitraryObject() {
+            return 1;
+        }
+    }
+    
+    @Test
+    public void acceptNonStaticTestRule() {
+        TestClass target = new TestClass(TestWithNonStaticTestRule.class);
+        RULE_VALIDATOR.validate(target, errors);
+        assertNumberOfErrors(0);
+    }
+
+    public static class TestWithNonStaticTestRule {
+        @Rule
+        public TestRule temporaryFolder = new TemporaryFolder();
+    }
+
+    @Test
+    public void rejectStaticTestRule() {
+        TestClass target = new TestClass(TestWithStaticTestRule.class);
+        RULE_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @Rule 'temporaryFolder' must not be static or it must be annotated with @ClassRule.");
+    }
+
+    public static class TestWithStaticTestRule {
+        @Rule
+        public static TestRule temporaryFolder = new TemporaryFolder();
+    }
+
+    @Test
+    public void rejectStaticMethodRule() {
+        TestClass target = new TestClass(TestWithStaticMethodRule.class);
+        RULE_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @Rule 'someMethodRule' must not be static.");
+    }
+
+    public static class TestWithStaticMethodRule {
+        @Rule
+        public static MethodRule someMethodRule = new SomeMethodRule();
+    }
+    
+    @Test
+    public void acceptMethodRule() throws Exception {
+        TestClass target = new TestClass(TestWithMethodRule.class);
+        RULE_VALIDATOR.validate(target, errors);
+        assertNumberOfErrors(0);
+    }
+
+    public static class TestWithMethodRule {
+        @Rule
+        public MethodRule temporaryFolder = new MethodRule() {
+            public Statement apply(Statement base, FrameworkMethod method,
+                    Object target) {
+                return null;
+            }
+        };
+    }
+
+    @Test
+    public void rejectArbitraryObjectWithRuleAnnotation() throws Exception {
+        TestClass target = new TestClass(TestWithArbitraryObjectWithRuleAnnotation.class);
+        RULE_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @Rule 'arbitraryObject' must implement MethodRule or TestRule.");
+    }
+
+    public static class TestWithArbitraryObjectWithRuleAnnotation {
+        @Rule
+        public Object arbitraryObject = 1;
+    }
+
+    @Test
+    public void methodRejectProtectedClassRule() {
+        TestClass target = new TestClass(MethodTestWithProtectedClassRule.class);
+        CLASS_RULE_METHOD_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @ClassRule 'getTemporaryFolder' must be public.");
+    }
+
+    public static class MethodTestWithProtectedClassRule {
+        @ClassRule
+        protected static TestRule getTemporaryFolder() {
+            return new TemporaryFolder();
+        }
+    }
+
+    @Test
+    public void methodRejectNonStaticClassRule() {
+        TestClass target = new TestClass(MethodTestWithNonStaticClassRule.class);
+        CLASS_RULE_METHOD_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @ClassRule 'getTemporaryFolder' must be static.");
+    }
+
+    public static class MethodTestWithNonStaticClassRule {
+        @ClassRule
+        public TestRule getTemporaryFolder() {
+            return new TemporaryFolder();
+        }
+    }
+
+    @Test
+    public void acceptMethodStaticTestRuleThatIsAlsoClassRule() {
+        TestClass target = new TestClass(MethodTestWithStaticClassAndTestRule.class);
+        CLASS_RULE_METHOD_VALIDATOR.validate(target, errors);
+        assertNumberOfErrors(0);
+    }
+
+    public static class MethodTestWithStaticClassAndTestRule {
+        @ClassRule
+        @Rule
+        public static TestRule getTemporaryFolder() {
+            return new TemporaryFolder();
+        }
+    }
+
+    @Test
+    public void acceptMethodNonStaticTestRule() {
+        TestClass target = new TestClass(TestMethodWithNonStaticTestRule.class);
+        RULE_METHOD_VALIDATOR.validate(target, errors);
+        assertNumberOfErrors(0);
+    }
+
+    public static class TestMethodWithNonStaticTestRule {
+        @Rule
+        public TestRule getTemporaryFolder() {
+            return new TemporaryFolder();
+        }
+    }
+
+    @Test
+    public void rejectMethodStaticTestRule() {
+        TestClass target = new TestClass(TestMethodWithStaticTestRule.class);
+        RULE_METHOD_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @Rule 'getTemporaryFolder' must not be static or it must be annotated with @ClassRule.");
+    }
+
+    public static class TestMethodWithStaticTestRule {
+        @Rule
+        public static TestRule getTemporaryFolder() {
+            return new TemporaryFolder();
+        }
+    }
+
+    @Test
+    public void rejectMethodStaticMethodRule() {
+        TestClass target = new TestClass(TestMethodWithStaticMethodRule.class);
+        RULE_METHOD_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @Rule 'getSomeMethodRule' must not be static.");
+    }
+
+    public static class TestMethodWithStaticMethodRule {
+        @Rule
+        public static MethodRule getSomeMethodRule() { return new SomeMethodRule(); }
+    }
+
+    @Test
+    public void methodAcceptMethodRuleMethod() throws Exception {
+        TestClass target = new TestClass(MethodTestWithMethodRule.class);
+        RULE_METHOD_VALIDATOR.validate(target, errors);
+        assertNumberOfErrors(0);
+    }
+
+    public static class MethodTestWithMethodRule {
+        @Rule
+        public MethodRule getTemporaryFolder() {
+            return new MethodRule() {
+                public Statement apply(Statement base, FrameworkMethod method,
+                        Object target) {
+                    return null;
+                }
+            };
+        }
+    }
+
+    @Test
+    public void methodRejectArbitraryObjectWithRuleAnnotation() throws Exception {
+        TestClass target = new TestClass(MethodTestWithArbitraryObjectWithRuleAnnotation.class);
+        RULE_METHOD_VALIDATOR.validate(target, errors);
+        assertOneErrorWithMessage("The @Rule 'getArbitraryObject' must return an implementation of MethodRule or TestRule.");
+    }
+
+    public static class MethodTestWithArbitraryObjectWithRuleAnnotation {
+        @Rule
+        public Object getArbitraryObject() {
+            return 1;
+        }
+    }
+
+    private void assertOneErrorWithMessage(String message) {
+        assertNumberOfErrors(1);
+        assertEquals("Wrong error message:", message, errors.get(0).getMessage());
+    }
+
+    private void assertNumberOfErrors(int numberOfErrors) {
+        assertEquals("Wrong number of errors:", numberOfErrors, errors.size());
+    }
+    
+    private static final class SomeMethodRule implements MethodRule {
+        public Statement apply(Statement base, FrameworkMethod method, Object target) {
+            return base;
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/StopwatchTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/StopwatchTest.java
new file mode 100644
index 0000000..5941eb9
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/StopwatchTest.java
@@ -0,0 +1,212 @@
+package org.junit.rules;
+
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+
+import java.util.concurrent.TimeUnit;
+
+import org.junit.AssumptionViolatedException;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+
+/**
+ * @author tibor17
+ * @since 4.12
+ */
+public class StopwatchTest {
+    private static enum TestStatus { SUCCEEDED, FAILED, SKIPPED }
+    private static Record record;
+    private static Record finishedRecord;
+    private static long fakeTimeNanos = 1234;
+
+    private static class Record {
+        final long duration;
+        final String name;
+        final TestStatus status;
+
+        Record() {
+            this(0, null, null);
+        }
+
+        Record(long duration, Description description) {
+            this(duration, null, description);
+        }
+
+        Record(long duration, TestStatus status, Description description) {
+            this.duration = duration;
+            this.status = status;
+            this.name = description == null ? null : description.getMethodName();
+        }
+    }
+
+    public abstract static class AbstractStopwatchTest {
+
+        /**
+         * Fake implementation of {@link Stopwatch.Clock} that increments the time
+         * every time it is asked.
+         */
+        private final Stopwatch.Clock fakeClock = new Stopwatch.Clock() {
+            @Override
+            public long nanoTime() {
+                return fakeTimeNanos++;
+            }
+        };
+
+        protected final Stopwatch stopwatch = new Stopwatch(fakeClock) {
+            @Override
+            protected void succeeded(long nanos, Description description) {
+                StopwatchTest.record = new Record(nanos, TestStatus.SUCCEEDED, description);
+                simulateTimePassing(1);
+            }
+
+            @Override
+            protected void failed(long nanos, Throwable e, Description description) {
+                StopwatchTest.record = new Record(nanos, TestStatus.FAILED, description);
+                simulateTimePassing(1);
+            }
+
+            @Override
+            protected void skipped(long nanos, AssumptionViolatedException e, Description description) {
+                StopwatchTest.record = new Record(nanos, TestStatus.SKIPPED, description);
+                simulateTimePassing(1);
+            }
+
+            @Override
+            protected void finished(long nanos, Description description) {
+                StopwatchTest.finishedRecord = new Record(nanos, description);
+            }
+        };
+
+        private final TestWatcher watcher = new TestWatcher() {
+            @Override
+            protected void finished(Description description) {
+                afterStopwatchRule();
+            }
+        };
+
+        @Rule
+        public final RuleChain chain = RuleChain
+            .outerRule(watcher)
+            .around(stopwatch);
+
+        protected void afterStopwatchRule() {
+        }
+    }
+
+    public static class SuccessfulTest extends AbstractStopwatchTest {
+        @Test
+        public void successfulTest() {
+        }
+    }
+
+    public static class FailedTest extends AbstractStopwatchTest {
+        @Test
+        public void failedTest() {
+            fail();
+        }
+    }
+
+    public static class SkippedTest extends AbstractStopwatchTest {
+        @Test
+        public void skippedTest() {
+            assumeTrue(false);
+        }
+    }
+
+    public static class DurationDuringTestTest extends AbstractStopwatchTest {
+        @Test
+        public void duration() {
+            simulateTimePassing(300L);
+            assertEquals(300L, stopwatch.runtime(MILLISECONDS));
+            simulateTimePassing(500L);
+            assertEquals(800L, stopwatch.runtime(MILLISECONDS));
+        }
+    }
+
+    public static class DurationAfterTestTest extends AbstractStopwatchTest {
+        @Test
+        public void duration() {
+            simulateTimePassing(300L);
+            assertEquals(300L, stopwatch.runtime(MILLISECONDS));
+        }
+
+        @Override
+        protected void afterStopwatchRule() {
+            assertEquals(300L, stopwatch.runtime(MILLISECONDS));
+            simulateTimePassing(500L);
+            assertEquals(300L, stopwatch.runtime(MILLISECONDS));
+        }
+    }
+
+    @Before
+    public void init() {
+        record = new Record();
+        finishedRecord = new Record();
+        simulateTimePassing(1L);
+    }
+
+    private static Result runTest(Class<?> test) {
+        simulateTimePassing(1L);
+        JUnitCore junitCore = new JUnitCore();
+        return junitCore.run(Request.aClass(test).getRunner());
+    }
+
+    private static void simulateTimePassing(long millis) {
+        fakeTimeNanos += TimeUnit.MILLISECONDS.toNanos(millis);
+    }
+
+    @Test
+    public void succeeded() {
+        Result result = runTest(SuccessfulTest.class);
+        assertEquals(0, result.getFailureCount());
+        assertThat(record.name, is("successfulTest"));
+        assertThat(record.name, is(finishedRecord.name));
+        assertThat(record.status, is(TestStatus.SUCCEEDED));
+        assertTrue("timeSpent > 0", record.duration > 0);
+        assertThat(record.duration, is(finishedRecord.duration));
+    }
+
+    @Test
+    public void failed() {
+        Result result = runTest(FailedTest.class);
+        assertEquals(1, result.getFailureCount());
+        assertThat(record.name, is("failedTest"));
+        assertThat(record.name, is(finishedRecord.name));
+        assertThat(record.status, is(TestStatus.FAILED));
+        assertTrue("timeSpent > 0", record.duration > 0);
+        assertThat(record.duration, is(finishedRecord.duration));
+    }
+
+    @Test
+    public void skipped() {
+        Result result = runTest(SkippedTest.class);
+        assertEquals(0, result.getFailureCount());
+        assertThat(record.name, is("skippedTest"));
+        assertThat(record.name, is(finishedRecord.name));
+        assertThat(record.status, is(TestStatus.SKIPPED));
+        assertTrue("timeSpent > 0", record.duration > 0);
+        assertThat(record.duration, is(finishedRecord.duration));
+    }
+
+    @Test
+    public void runtimeDuringTestShouldReturnTimeSinceStart() {
+        Result result = runTest(DurationDuringTestTest.class);
+        assertTrue(result.wasSuccessful());
+    }
+
+  @Test
+    public void runtimeAfterTestShouldReturnRunDuration() {
+        Result result = runTest(DurationAfterTestTest.class);
+        assertTrue(result.wasSuccessful());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/TempFolderRuleTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/TempFolderRuleTest.java
new file mode 100644
index 0000000..b120e71
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/TempFolderRuleTest.java
@@ -0,0 +1,281 @@
+package org.junit.rules;
+
+import static org.hamcrest.CoreMatchers.hasItem;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.failureCountIs;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import org.junit.After;
+import org.junit.AssumptionViolatedException;
+import org.junit.Rule;
+import org.junit.Test;
+
+public class TempFolderRuleTest {
+    private static File[] createdFiles = new File[20];
+
+    public static class HasTempFolder {
+        @Rule
+        public TemporaryFolder folder = new TemporaryFolder();
+
+        @Test
+        public void testUsingTempFolder() throws IOException {
+            createdFiles[0] = folder.newFile("myfile.txt");
+            assertTrue(createdFiles[0].exists());
+        }
+
+        @Test
+        public void testTempFolderLocation() throws IOException {
+            File folderRoot = folder.getRoot();
+            String tmpRoot = System.getProperty("java.io.tmpdir");
+            assertTrue(folderRoot.toString().startsWith(tmpRoot));
+        }
+    }
+
+    @Test
+    public void tempFolderIsDeleted() {
+        assertThat(testResult(HasTempFolder.class), isSuccessful());
+        assertFalse(createdFiles[0].exists());
+    }
+
+    public static class CreatesSubFolder {
+        @Rule
+        public TemporaryFolder folder = new TemporaryFolder();
+
+        @Test
+        public void testUsingTempFolderStringReflection() throws Exception {
+            String subfolder = "subfolder";
+            String filename = "a.txt";
+            // force usage of folder.newFolder(String),
+            // check is available and works, to avoid a potential NoSuchMethodError with non-recompiled code.
+            Method method = folder.getClass().getMethod("newFolder", new Class<?>[]{String.class});
+            createdFiles[0] = (File) method.invoke(folder, subfolder);
+            new File(createdFiles[0], filename).createNewFile();
+
+            File expectedFile = new File(folder.getRoot(), join(subfolder, filename));
+
+            assertTrue(expectedFile.exists());
+        }
+
+        @Test
+        public void testUsingTempFolderString() throws IOException {
+            String subfolder = "subfolder";
+            String filename = "a.txt";
+            // this uses newFolder(String), ensure that a single String works
+            createdFiles[0] = folder.newFolder(subfolder);
+            new File(createdFiles[0], filename).createNewFile();
+
+            File expectedFile = new File(folder.getRoot(), join(subfolder, filename));
+
+            assertTrue(expectedFile.exists());
+        }
+
+        @Test
+        public void testUsingTempTreeFolders() throws IOException {
+            String subfolder = "subfolder";
+            String anotherfolder = "anotherfolder";
+            String filename = "a.txt";
+
+            createdFiles[0] = folder.newFolder(subfolder, anotherfolder);
+            new File(createdFiles[0], filename).createNewFile();
+
+            File expectedFile = new File(folder.getRoot(), join(subfolder, anotherfolder, filename));
+
+            assertTrue(expectedFile.exists());
+        }
+
+        private String join(String... folderNames) {
+            StringBuilder path = new StringBuilder();
+            for (String folderName : folderNames) {
+                path.append(File.separator).append(folderName);
+            }
+            return path.toString();
+        }
+    }
+
+    @Test
+    public void subFolderIsDeleted() {
+        assertThat(testResult(CreatesSubFolder.class), isSuccessful());
+        assertFalse(createdFiles[0].exists());
+    }
+
+    public static class CreatesRandomSubFolders {
+        @Rule
+        public TemporaryFolder folder = new TemporaryFolder();
+
+        @Test
+        public void testUsingRandomTempFolders() throws IOException {
+            for (int i = 0; i < 20; i++) {
+                File newFolder = folder.newFolder();
+                assertThat(Arrays.asList(createdFiles), not(hasItem(newFolder)));
+                createdFiles[i] = newFolder;
+                new File(newFolder, "a.txt").createNewFile();
+                assertTrue(newFolder.exists());
+            }
+        }
+    }
+
+    @Test
+    public void randomSubFoldersAreDeleted() {
+        assertThat(testResult(CreatesRandomSubFolders.class), isSuccessful());
+        for (File f : createdFiles) {
+            assertFalse(f.exists());
+        }
+    }
+
+    public static class CreatesRandomFiles {
+        @Rule
+        public TemporaryFolder folder = new TemporaryFolder();
+
+        @Test
+        public void testUsingRandomTempFiles() throws IOException {
+            for (int i = 0; i < 20; i++) {
+                File newFile = folder.newFile();
+                assertThat(Arrays.asList(createdFiles), not(hasItem(newFile)));
+                createdFiles[i] = newFile;
+                assertTrue(newFile.exists());
+            }
+        }
+    }
+
+    @Test
+    public void randomFilesAreDeleted() {
+        assertThat(testResult(CreatesRandomFiles.class), isSuccessful());
+        for (File f : createdFiles) {
+            assertFalse(f.exists());
+        }
+    }
+
+    @Test
+    public void recursiveDeleteFolderWithOneElement() throws IOException {
+        TemporaryFolder folder = new TemporaryFolder();
+        folder.create();
+        File file = folder.newFile("a");
+        folder.delete();
+        assertFalse(file.exists());
+        assertFalse(folder.getRoot().exists());
+    }
+
+    @Test
+    public void recursiveDeleteFolderWithOneRandomElement() throws IOException {
+        TemporaryFolder folder = new TemporaryFolder();
+        folder.create();
+        File file = folder.newFile();
+        folder.delete();
+        assertFalse(file.exists());
+        assertFalse(folder.getRoot().exists());
+    }
+
+    @Test
+    public void recursiveDeleteFolderWithZeroElements() throws IOException {
+        TemporaryFolder folder = new TemporaryFolder();
+        folder.create();
+        folder.delete();
+        assertFalse(folder.getRoot().exists());
+    }
+
+    @Test
+    public void tempFolderIsOnlyAccessibleByOwner() throws IOException {
+        TemporaryFolder folder = new TemporaryFolder();
+        folder.create();
+
+        Set<String> expectedPermissions = new TreeSet<String>(Arrays.asList("OWNER_READ", "OWNER_WRITE", "OWNER_EXECUTE"));
+        Set<String> actualPermissions = getPosixFilePermissions(folder.getRoot());
+        assertEquals(expectedPermissions, actualPermissions);
+    }
+
+    private Set<String> getPosixFilePermissions(File root) {
+        try {
+            Class<?> pathClass = Class.forName("java.nio.file.Path");
+            Object linkOptionArray = Array.newInstance(Class.forName("java.nio.file.LinkOption"), 0);
+            Class<?> filesClass = Class.forName("java.nio.file.Files");
+            Object path = File.class.getDeclaredMethod("toPath").invoke(root);
+            Method posixFilePermissionsMethod = filesClass.getDeclaredMethod("getPosixFilePermissions", pathClass, linkOptionArray.getClass());
+            Set<?> permissions = (Set<?>) posixFilePermissionsMethod.invoke(null, path, linkOptionArray);
+            SortedSet<String> convertedPermissions = new TreeSet<String>();
+            for (Object item : permissions) {
+                convertedPermissions.add(item.toString());
+            }
+            return convertedPermissions;
+        } catch (Exception e) {
+            throw new AssumptionViolatedException("Test requires at least Java 1.7", e);
+        }
+    }
+
+    public static class NameClashes {
+        @Rule
+        public TemporaryFolder folder = new TemporaryFolder();
+
+        @Test
+        public void fileWithFileClash() throws IOException {
+            folder.newFile("something.txt");
+            folder.newFile("something.txt");
+        }
+
+        @Test
+        public void fileWithFolderTest() throws IOException {
+            folder.newFolder("dummy");
+            folder.newFile("dummy");
+        }
+    }
+
+    @Test
+    public void nameClashesResultInTestFailures() {
+        assertThat(testResult(NameClashes.class), failureCountIs(2));
+    }
+
+    private static final String GET_ROOT_DUMMY = "dummy-getRoot";
+
+    private static final String NEW_FILE_DUMMY = "dummy-newFile";
+
+    private static final String NEW_FOLDER_DUMMY = "dummy-newFolder";
+
+    public static class IncorrectUsage {
+        public TemporaryFolder folder = new TemporaryFolder();
+
+        @Test
+        public void testGetRoot() throws IOException {
+            new File(folder.getRoot(), GET_ROOT_DUMMY).createNewFile();
+        }
+
+        @Test
+        public void testNewFile() throws IOException {
+            folder.newFile(NEW_FILE_DUMMY);
+        }
+
+        @Test
+        public void testNewFolder() throws IOException {
+            folder.newFolder(NEW_FOLDER_DUMMY);
+        }
+    }
+
+    @Test
+    public void incorrectUsageWithoutApplyingTheRuleShouldNotPolluteTheCurrentWorkingDirectory() {
+        assertThat(testResult(IncorrectUsage.class), failureCountIs(3));
+        assertFalse("getRoot should have failed early", new File(GET_ROOT_DUMMY).exists());
+        assertFalse("newFile should have failed early", new File(NEW_FILE_DUMMY).exists());
+        assertFalse("newFolder should have failed early", new File(NEW_FOLDER_DUMMY).exists());
+    }
+
+    @After
+    public void cleanCurrentWorkingDirectory() {
+        new File(GET_ROOT_DUMMY).delete();
+        new File(NEW_FILE_DUMMY).delete();
+        new File(NEW_FOLDER_DUMMY).delete();
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/TemporaryFolderRuleAssuredDeletionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/TemporaryFolderRuleAssuredDeletionTest.java
new file mode 100644
index 0000000..48cbb44
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/TemporaryFolderRuleAssuredDeletionTest.java
@@ -0,0 +1,45 @@
+package org.junit.rules;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.failureCountIs;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.results.PrintableResult;
+
+public class TemporaryFolderRuleAssuredDeletionTest {
+
+    public static class TestClass {
+        static TemporaryFolder injectedRule;
+
+        @Rule
+        public TemporaryFolder folder = injectedRule;
+
+        @Test
+        public void alwaysPassesButDeletesRootFolder() {
+            //we delete the folder in the test so that it cannot be deleted by
+            //the rule
+            folder.getRoot().delete();
+        }
+    }
+
+    @Test
+    public void testFailsWhenCreatedFolderCannotBeDeletedButDeletionIsAssured() {
+        TestClass.injectedRule = TemporaryFolder.builder()
+                .assureDeletion()
+                .build();
+        PrintableResult result = testResult(TestClass.class);
+        assertThat(result, failureCountIs(1));
+        assertThat(result.toString(), containsString("Unable to clean up temporary folder"));
+    }
+
+    @Test
+    public void byDefaultTestDoesNotFailWhenCreatedFolderCannotBeDeleted() {
+        TestClass.injectedRule = new TemporaryFolder();
+        PrintableResult result = testResult(TestClass.class);
+        assertThat(result, isSuccessful());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/TemporaryFolderUsageTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/TemporaryFolderUsageTest.java
new file mode 100644
index 0000000..584a296
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/TemporaryFolderUsageTest.java
@@ -0,0 +1,302 @@
+package org.junit.rules;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+/**
+ * <tt>TemporaryFolderUsageTest</tt> provides tests for API usage correctness
+ * and ensure implementation symmetry of public methods against a root folder.
+ */
+public class TemporaryFolderUsageTest {
+
+    private TemporaryFolder tempFolder;
+
+    @Rule
+    public final ExpectedException thrown = ExpectedException.none();
+
+    @Before
+    public void setUp() {
+        tempFolder = new TemporaryFolder();
+    }
+
+    @After
+    public void tearDown() {
+        tempFolder.delete();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void getRootShouldThrowIllegalStateExceptionIfCreateWasNotInvoked() {
+        new TemporaryFolder().getRoot();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void newFileThrowsIllegalStateExceptionIfCreateWasNotInvoked()
+            throws IOException {
+        new TemporaryFolder().newFile();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void newFileWithGivenNameThrowsIllegalStateExceptionIfCreateWasNotInvoked()
+            throws IOException {
+        new TemporaryFolder().newFile("MyFile.txt");
+    }
+
+    @Test
+    public void newFileWithGivenFilenameThrowsIOExceptionIfFileExists() throws IOException {
+        tempFolder.create();
+        tempFolder.newFile("MyFile.txt");
+
+        thrown.expect(IOException.class);
+        thrown.expectMessage("a file with the name 'MyFile.txt' already exists in the test folder");
+        tempFolder.newFile("MyFile.txt");
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void newFolderThrowsIllegalStateExceptionIfCreateWasNotInvoked()
+            throws IOException {
+        new TemporaryFolder().newFolder();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void newFolderWithGivenPathThrowsIllegalStateExceptionIfCreateWasNotInvoked() throws IOException {
+        new TemporaryFolder().newFolder("level1", "level2", "level3");
+    }
+
+    @Test
+    public void newFolderWithGivenFolderThrowsIOExceptionIfFolderExists() throws IOException {
+        tempFolder.create();
+        tempFolder.newFolder("level1");
+
+        thrown.expect(IOException.class);
+        thrown.expectMessage("a folder with the path 'level1' already exists");
+        tempFolder.newFolder("level1");
+    }
+
+    @Test
+    public void newFolderWithGivenFolderThrowsIOExceptionIfFileExists() throws IOException {
+        tempFolder.create();
+        File file = new File(tempFolder.getRoot(), "level1");
+        assertTrue("Could not create" + file, file.createNewFile());
+
+        thrown.expect(IOException.class);
+        thrown.expectMessage("a file with the path 'level1' exists");
+        tempFolder.newFolder("level1");
+    }
+
+    @Test
+    public void newFolderWithGivenFolderThrowsIOExceptionWhenFolderCannotBeCreated() throws IOException {
+        tempFolder.create();
+        assumeTrue("Could not make folder " + tempFolder.getRoot() + " read only.",
+                tempFolder.getRoot().setReadOnly());
+
+        thrown.expect(IOException.class);
+        thrown.expectMessage("could not create a folder with the path 'level1'");
+        tempFolder.newFolder("level1");
+    }
+    
+    @Test
+    public void newFolderWithPathStartingWithFileSeparatorThrowsIOException()
+            throws IOException {
+        String fileAtRoot;
+        File[] roots = File.listRoots();
+        if (roots != null && roots.length > 0) {
+            fileAtRoot = roots[0].getAbsolutePath() + "temp1";
+        } else {
+            fileAtRoot = File.separator + "temp1";
+        }
+        tempFolder.create();
+        thrown.expect(IOException.class);
+        thrown.expectMessage("folder path '" + fileAtRoot + "' is not a relative path");
+        tempFolder.newFolder(fileAtRoot);
+    }
+    
+    @Test
+    public void newFolderWithPathContainingFileSeparatorCreatesDirectories()
+            throws IOException {
+        tempFolder.create();
+        tempFolder.newFolder("temp1" + File.separator + "temp2");
+        File temp1 = new File(tempFolder.getRoot(), "temp1");
+        assertFileIsDirectory(temp1);
+        assertFileIsDirectory(new File(temp1, "temp2"));
+    }
+ 
+    @Test
+    public void newFolderWithPathContainingForwardSlashCreatesDirectories()
+            throws IOException {
+        tempFolder.create();
+        tempFolder.newFolder("temp1/temp2");
+        File temp1 = new File(tempFolder.getRoot(), "temp1");
+        assertFileIsDirectory(temp1);
+        assertFileIsDirectory(new File(temp1, "temp2"));
+    }
+    
+    @Test
+    public void newFolderWithGivenPathThrowsIOExceptionIfFolderExists() throws IOException {
+        tempFolder.create();
+        tempFolder.newFolder("level1", "level2", "level3");
+
+        thrown.expect(IOException.class);
+        String path = "level1" + File.separator + "level2" + File.separator + "level3";
+        thrown.expectMessage("a folder with the path '" + path + "' already exists");
+        tempFolder.newFolder("level1", "level2", "level3");
+    }
+
+    @Test
+    public void newFolderWithGivenEmptyArrayThrowsIllegalArgumentException() throws IOException {
+        tempFolder.create();
+
+        thrown.expect(IllegalArgumentException.class);
+        thrown.expectMessage("must pass at least one path");
+        tempFolder.newFolder(new String[0]);
+    }
+
+    @Test
+    public void newFolderWithPathsContainingForwardSlashCreatesFullPath()
+            throws IOException {
+        tempFolder.create();
+        tempFolder.newFolder("temp1", "temp2", "temp3/temp4");
+
+        File directory = new File(tempFolder.getRoot(), "temp1");
+        assertFileIsDirectory(directory);
+        directory = new File(directory, "temp2/temp3/temp4");
+        assertFileIsDirectory(directory);
+    }
+
+    @Test
+    public void newFolderWithPathsContainingFileSeparatorCreatesFullPath()
+            throws IOException {
+        tempFolder.create();
+        tempFolder.newFolder("temp1", "temp2", "temp3" + File.separator + "temp4");
+
+        File directory = new File(tempFolder.getRoot(), "temp1");
+        assertFileIsDirectory(directory);
+        directory = new File(directory, "temp2/temp3/temp4");
+        assertFileIsDirectory(directory);
+    }
+    
+    @Test
+    public void createInitializesRootFolder() throws IOException {
+        tempFolder.create();
+        assertFileIsDirectory(tempFolder.getRoot());
+    }
+
+    @Test
+    public void deleteShouldDoNothingIfRootFolderWasNotInitialized() {
+        tempFolder.delete();
+    }
+
+    @Test
+    public void deleteRemovesRootFolder() throws IOException {
+        tempFolder.create();
+        tempFolder.delete();
+        assertFileDoesNotExist(tempFolder.getRoot());
+    }
+
+    @Test
+    public void newRandomFileIsCreatedUnderRootFolder() throws IOException {
+        tempFolder.create();
+
+        File f = tempFolder.newFile();
+        assertFileExists(f);
+        assertFileCreatedUnderRootFolder("Random file", f);
+    }
+
+    @Test
+    public void newNamedFileIsCreatedUnderRootFolder() throws IOException {
+        final String fileName = "SampleFile.txt";
+        tempFolder.create();
+
+        File f = tempFolder.newFile(fileName);
+
+        assertFileExists(f);
+        assertFileCreatedUnderRootFolder("Named file", f);
+        assertThat("file name", f.getName(), equalTo(fileName));
+    }
+
+    @Test
+    public void newRandomFolderIsCreatedUnderRootFolder() throws IOException {
+        tempFolder.create();
+
+        File f = tempFolder.newFolder();
+        assertFileIsDirectory(f);
+        assertFileCreatedUnderRootFolder("Random folder", f);
+    }
+
+    @Test
+    public void newNestedFoldersCreatedUnderRootFolder() throws IOException {
+        tempFolder.create();
+
+        File f = tempFolder.newFolder("top", "middle", "bottom");
+        assertFileIsDirectory(f);
+        assertParentFolderForFileIs(f, new File(tempFolder.getRoot(),
+                "top/middle"));
+        assertParentFolderForFileIs(f.getParentFile(),
+                new File(tempFolder.getRoot(), "top"));
+        assertFileCreatedUnderRootFolder("top", f.getParentFile()
+                .getParentFile());
+    }
+
+    @Test
+    public void canSetTheBaseFileForATemporaryFolder() throws IOException {
+        File tempDir = createTemporaryFolder();
+
+        TemporaryFolder folder = new TemporaryFolder(tempDir);
+        folder.create();
+
+        assertThat(tempDir, is(folder.getRoot().getParentFile()));
+    }
+
+    private File createTemporaryFolder() throws IOException {
+        File tempDir = File.createTempFile("junit", "tempFolder");
+        assertTrue("Unable to delete temporary file", tempDir.delete());
+        assertTrue("Unable to create temp directory", tempDir.mkdir());
+        return tempDir;
+    }
+
+    private void assertFileDoesNotExist(File file) {
+        checkFileExists("exists", file, false);
+    }
+
+    private void checkFileExists(String msg, File file, boolean exists) {
+        assertThat("File is null", file, is(notNullValue()));
+        assertThat("File '" + file.getAbsolutePath() + "' " + msg,
+                file.exists(), is(exists));
+    }
+
+    private void checkFileIsDirectory(String msg, File file, boolean isDirectory) {
+        assertThat("File is null", file, is(notNullValue()));
+        assertThat("File '" + file.getAbsolutePath() + "' " + msg,
+                file.isDirectory(), is(isDirectory));
+    }
+
+    private void assertFileExists(File file) {
+        checkFileExists("does not exist", file, true);
+        checkFileIsDirectory("is a directory", file, false);
+    }
+
+    private void assertFileIsDirectory(File file) {
+        checkFileExists("does not exist", file, true);
+        checkFileIsDirectory("is not a directory", file, true);
+    }
+
+    private void assertFileCreatedUnderRootFolder(String msg, File f) {
+        assertParentFolderForFileIs(f, tempFolder.getRoot());
+    }
+
+    private void assertParentFolderForFileIs(File f, File parentFolder) {
+        assertThat("'" + f.getAbsolutePath() + "': not under root",
+                f.getParentFile(), is(parentFolder));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/TestRuleTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/TestRuleTest.java
new file mode 100644
index 0000000..cc6db7d
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/TestRuleTest.java
@@ -0,0 +1,610 @@
+package org.junit.rules;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+public class TestRuleTest {
+    private static boolean wasRun;
+
+    public static class ExampleTest {
+        @Rule
+        public TestRule example = new TestRule() {
+            public Statement apply(final Statement base, Description description) {
+                return new Statement() {
+                    @Override
+                    public void evaluate() throws Throwable {
+                        wasRun = true;
+                        base.evaluate();
+                    }
+                };
+            }
+        };
+
+        @Test
+        public void nothing() {
+
+        }
+    }
+
+    @Test
+    public void ruleIsIntroducedAndEvaluated() {
+        wasRun = false;
+        JUnitCore.runClasses(ExampleTest.class);
+        assertTrue(wasRun);
+    }
+
+    public static class BothKindsOfRule implements TestRule, org.junit.rules.MethodRule {
+        public int applications = 0;
+
+        public Statement apply(Statement base, FrameworkMethod method,
+                Object target) {
+            applications++;
+            return base;
+        }
+
+        public Statement apply(Statement base, Description description) {
+            applications++;
+            return base;
+        }
+    }
+
+    public static class OneFieldTwoKindsOfRule {
+        @Rule
+        public BothKindsOfRule both = new BothKindsOfRule();
+
+        @Test
+        public void onlyOnce() {
+            assertEquals(1, both.applications);
+        }
+    }
+
+
+    @Test
+    public void onlyApplyOnceEvenIfImplementsBothInterfaces() {
+        assertTrue(JUnitCore.runClasses(OneFieldTwoKindsOfRule.class).wasSuccessful());
+    }
+
+    public static class SonOfExampleTest extends ExampleTest {
+
+    }
+
+    @Test
+    public void ruleIsIntroducedAndEvaluatedOnSubclass() {
+        wasRun = false;
+        JUnitCore.runClasses(SonOfExampleTest.class);
+        assertTrue(wasRun);
+    }
+
+    private static int runCount;
+
+    public static class MultipleRuleTest {
+        private static class Increment implements TestRule {
+            public Statement apply(final Statement base, Description description) {
+                return new Statement() {
+                    @Override
+                    public void evaluate() throws Throwable {
+                        runCount++;
+                        base.evaluate();
+                    }
+                };
+            }
+        }
+
+        @Rule
+        public TestRule incrementor1 = new Increment();
+
+        @Rule
+        public TestRule incrementor2 = new Increment();
+
+        @Test
+        public void nothing() {
+
+        }
+    }
+
+    @Test
+    public void multipleRulesAreRun() {
+        runCount = 0;
+        JUnitCore.runClasses(MultipleRuleTest.class);
+        assertEquals(2, runCount);
+    }
+
+    public static class NoRulesTest {
+        public int x;
+
+        @Test
+        public void nothing() {
+
+        }
+    }
+
+    @Test
+    public void ignoreNonRules() {
+        Result result = JUnitCore.runClasses(NoRulesTest.class);
+        assertEquals(0, result.getFailureCount());
+    }
+
+    private static String log;
+
+    public static class BeforesAndAfters {
+        private static StringBuilder watchedLog = new StringBuilder();
+
+        @Before
+        public void before() {
+            watchedLog.append("before ");
+        }
+
+        @Rule
+        public TestRule watcher = new LoggingTestWatcher(watchedLog);
+
+        @After
+        public void after() {
+            watchedLog.append("after ");
+        }
+
+        @Test
+        public void succeeds() {
+            watchedLog.append("test ");
+        }
+    }
+
+    @Test
+    public void beforesAndAfters() {
+        BeforesAndAfters.watchedLog = new StringBuilder();
+        JUnitCore.runClasses(BeforesAndAfters.class);
+        assertThat(BeforesAndAfters.watchedLog.toString(),
+                is("starting before test after succeeded finished "));
+    }
+
+    public static class WrongTypedField {
+        @Rule
+        public int x = 5;
+
+        @Test
+        public void foo() {
+        }
+    }
+
+    @Test
+    public void validateWrongTypedField() {
+        assertThat(testResult(WrongTypedField.class),
+                hasSingleFailureContaining("must implement MethodRule"));
+    }
+
+    public static class SonOfWrongTypedField extends WrongTypedField {
+
+    }
+
+    @Test
+    public void validateWrongTypedFieldInSuperclass() {
+        assertThat(testResult(SonOfWrongTypedField.class),
+                hasSingleFailureContaining("must implement MethodRule"));
+    }
+
+    public static class PrivateRule {
+        @Rule
+        private TestRule rule = new TestName();
+
+        @Test
+        public void foo() {
+        }
+    }
+
+    @Test
+    public void validatePrivateRule() {
+        assertThat(testResult(PrivateRule.class),
+                hasSingleFailureContaining("must be public"));
+    }
+
+    public static class CustomTestName implements TestRule {
+        public String name = null;
+
+        public Statement apply(final Statement base, final Description description) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    name = description.getMethodName();
+                    base.evaluate();
+                }
+            };
+        }
+    }
+
+    public static class UsesCustomMethodRule {
+        @Rule
+        public CustomTestName counter = new CustomTestName();
+
+        @Test
+        public void foo() {
+            assertEquals("foo", counter.name);
+        }
+    }
+
+    @Test
+    public void useCustomMethodRule() {
+        assertThat(testResult(UsesCustomMethodRule.class), isSuccessful());
+    }
+
+    public static class MethodExampleTest {
+        private TestRule example = new TestRule() {
+            public Statement apply(final Statement base, Description description) {
+                return new Statement() {
+                    @Override
+                    public void evaluate() throws Throwable {
+                        wasRun = true;
+                        base.evaluate();
+                    }
+                };
+            }
+        };
+
+        @Rule
+        public TestRule getExample() {
+            return example;
+        }
+
+        @Test
+        public void nothing() {
+
+        }
+    }
+
+    @Test
+    public void methodRuleIsIntroducedAndEvaluated() {
+        wasRun = false;
+        JUnitCore.runClasses(MethodExampleTest.class);
+        assertTrue(wasRun);
+    }
+
+    public static class MethodBothKindsOfRule implements TestRule, org.junit.rules.MethodRule {
+        public int applications = 0;
+
+        public Statement apply(Statement base, FrameworkMethod method,
+                Object target) {
+            applications++;
+            return base;
+        }
+
+        public Statement apply(Statement base, Description description) {
+            applications++;
+            return base;
+        }
+    }
+
+    public static class MethodOneFieldTwoKindsOfRule {
+        private MethodBothKindsOfRule both = new MethodBothKindsOfRule();
+
+        @Rule
+        public MethodBothKindsOfRule getBoth() {
+            return both;
+        }
+
+        @Test
+        public void onlyOnce() {
+            assertEquals(1, both.applications);
+        }
+    }
+
+
+    @Test
+    public void methodOnlyApplyOnceEvenIfImplementsBothInterfaces() {
+        assertTrue(JUnitCore.runClasses(MethodOneFieldTwoKindsOfRule.class).wasSuccessful());
+    }
+
+    public static class MethodSonOfExampleTest extends MethodExampleTest {
+
+    }
+
+    @Test
+    public void methodRuleIsIntroducedAndEvaluatedOnSubclass() {
+        wasRun = false;
+        JUnitCore.runClasses(MethodSonOfExampleTest.class);
+        assertTrue(wasRun);
+    }
+
+    public static class MethodMultipleRuleTest {
+        private static class Increment implements TestRule {
+            public Statement apply(final Statement base, Description description) {
+                return new Statement() {
+                    @Override
+                    public void evaluate() throws Throwable {
+                        runCount++;
+                        base.evaluate();
+                    }
+                };
+            }
+        }
+
+        private TestRule incrementor1 = new Increment();
+
+        @Rule
+        public TestRule getIncrementor1() {
+            return incrementor1;
+        }
+
+        private TestRule incrementor2 = new Increment();
+
+        @Rule
+        public TestRule getIncrementor2() {
+            return incrementor2;
+        }
+
+        @Test
+        public void nothing() {
+
+        }
+    }
+
+    @Test
+    public void methodMultipleRulesAreRun() {
+        runCount = 0;
+        JUnitCore.runClasses(MethodMultipleRuleTest.class);
+        assertEquals(2, runCount);
+    }
+
+    public static class MethodNoRulesTest {
+        public int x;
+
+        @Test
+        public void nothing() {
+
+        }
+    }
+
+    @Test
+    public void methodIgnoreNonRules() {
+        Result result = JUnitCore.runClasses(MethodNoRulesTest.class);
+        assertEquals(0, result.getFailureCount());
+    }
+
+    public static class BeforesAndAftersAreEnclosedByRule {
+        private static StringBuilder log;
+
+        @Rule
+        public TestRule watcher = new LoggingTestWatcher(log);
+
+        @Before
+        public void before() {
+            log.append("before ");
+        }
+
+        @After
+        public void after() {
+            log.append("after ");
+        }
+
+        @Test
+        public void succeeds() {
+            log.append("test ");
+        }
+    }
+
+    @Test
+    public void beforesAndAftersAreEnclosedByRule() {
+        BeforesAndAftersAreEnclosedByRule.log = new StringBuilder();
+        JUnitCore.runClasses(BeforesAndAftersAreEnclosedByRule.class);
+        assertEquals("starting before test after succeeded finished ",
+                BeforesAndAftersAreEnclosedByRule.log.toString());
+    }
+
+    public static class MethodWrongTypedField {
+        @Rule
+        public int getX() {
+            return 5;
+        }
+
+        @Test
+        public void foo() {
+        }
+    }
+
+    @Test
+    public void methodValidateWrongTypedField() {
+        assertThat(testResult(MethodWrongTypedField.class),
+                hasSingleFailureContaining("must return an implementation of MethodRule"));
+    }
+
+    public static class MethodSonOfWrongTypedField extends MethodWrongTypedField {
+
+    }
+
+    @Test
+    public void methodValidateWrongTypedFieldInSuperclass() {
+        assertThat(testResult(MethodSonOfWrongTypedField.class),
+                hasSingleFailureContaining("must return an implementation of MethodRule"));
+    }
+
+    public static class MethodPrivateRule {
+        @Rule
+        private TestRule getRule() {
+            return new TestName();
+        }
+
+        @Test
+        public void foo() {
+        }
+    }
+
+    @Test
+    public void methodValidatePrivateRule() {
+        assertThat(testResult(MethodPrivateRule.class),
+                hasSingleFailureContaining("must be public"));
+    }
+
+    public static class MethodUsesCustomMethodRule {
+        private CustomTestName counter = new CustomTestName();
+
+        @Rule
+        public CustomTestName getCounter() {
+            return counter;
+        }
+
+        @Test
+        public void foo() {
+            assertEquals("foo", counter.name);
+        }
+    }
+
+    @Test
+    public void methodUseCustomMethodRule() {
+        assertThat(testResult(MethodUsesCustomMethodRule.class), isSuccessful());
+    }
+
+    private static final List<String> orderList = new LinkedList<String>();
+
+    private static class OrderTestRule implements TestRule {
+        private String name;
+
+        public OrderTestRule(String name) {
+            this.name = name;
+        }
+
+        public Statement apply(final Statement base, final Description description) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    orderList.add(name);
+                    base.evaluate();
+                }
+            };
+        }
+    }
+
+    public static class UsesFieldAndMethodRule {
+        @Rule
+        public OrderTestRule orderMethod() {
+            return new OrderTestRule("orderMethod");
+        }
+
+        @Rule
+        public OrderTestRule orderField = new OrderTestRule("orderField");
+
+        @Test
+        public void foo() {
+            assertEquals("orderField", orderList.get(0));
+            assertEquals("orderMethod", orderList.get(1));
+        }
+    }
+
+    @Test
+    public void usesFieldAndMethodRule() {
+        orderList.clear();
+        assertThat(testResult(UsesFieldAndMethodRule.class), isSuccessful());
+    }
+
+    public static class CallMethodOnlyOnceRule {
+        int countOfMethodCalls = 0;
+
+        private static class Dummy implements TestRule {
+            public Statement apply(final Statement base, Description description) {
+                return new Statement() {
+                    @Override
+                    public void evaluate() throws Throwable {
+                        base.evaluate();
+                    }
+                };
+            }
+        }
+
+        @Rule
+        public Dummy both() {
+            countOfMethodCalls++;
+            return new Dummy();
+        }
+
+        @Test
+        public void onlyOnce() {
+            assertEquals(1, countOfMethodCalls);
+        }
+    }
+
+    @Test
+    public void testCallMethodOnlyOnceRule() {
+        assertTrue(JUnitCore.runClasses(CallMethodOnlyOnceRule.class).wasSuccessful());
+    }
+
+    private static final StringBuilder ruleLog = new StringBuilder();
+
+    public static class TestRuleIsAroundMethodRule {
+        @Rule
+        public final MethodRule z = new LoggingMethodRule(ruleLog, "methodRule");
+
+        @Rule
+        public final TestRule a = new LoggingTestRule(ruleLog, "testRule");
+
+        @Test
+        public void foo() {
+            ruleLog.append(" foo");
+        }
+    }
+
+    @Test
+    public void testRuleIsAroundMethodRule() {
+        ruleLog.setLength(0);
+        Result result = JUnitCore.runClasses(TestRuleIsAroundMethodRule.class);
+        assertTrue(result.wasSuccessful());
+        assertEquals(" testRule.begin methodRule.begin foo methodRule.end testRule.end",
+                ruleLog.toString());
+    }
+
+    public static class TestRuleOrdering {
+        @Rule(order = 1)
+        public final TestRule a = new LoggingTestRule(ruleLog, "outer");
+
+        @Rule(order = 2)
+        public final TestRule z = new LoggingTestRule(ruleLog, "inner");
+
+        @Test
+        public void foo() {
+            ruleLog.append(" foo");
+        }
+    }
+
+    @Test
+    public void testRuleOrdering() {
+        ruleLog.setLength(0);
+        Result result = JUnitCore.runClasses(TestRuleOrdering.class);
+        assertTrue(result.wasSuccessful());
+        assertEquals(" outer.begin inner.begin foo inner.end outer.end", ruleLog.toString());
+    }
+
+    public static class TestRuleOrderingWithMethodRule {
+        @Rule(order = 1)
+        public final MethodRule z = new LoggingMethodRule(ruleLog, "methodRule");
+
+        @Rule(order = 2)
+        public final TestRule a = new LoggingTestRule(ruleLog, "testRule");
+
+        @Test
+        public void foo() {
+            ruleLog.append(" foo");
+        }
+    }
+
+    @Test
+    public void testRuleOrderingWithMethodRule() {
+        ruleLog.setLength(0);
+        Result result = JUnitCore.runClasses(TestRuleOrderingWithMethodRule.class);
+        assertTrue(result.wasSuccessful());
+        assertEquals(" methodRule.begin testRule.begin foo testRule.end methodRule.end",
+                ruleLog.toString());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/TestWatcherTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/TestWatcherTest.java
new file mode 100644
index 0000000..e09e23c
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/TestWatcherTest.java
@@ -0,0 +1,397 @@
+package org.junit.rules;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.*;
+import static org.junit.Assume.assumeTrue;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.failureCountIs;
+import static org.junit.experimental.results.ResultMatchers.hasFailureContaining;
+import static org.junit.rules.ExpectedException.none;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.results.PrintableResult;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.junit.runners.model.Statement;
+
+import java.util.List;
+
+@RunWith(Enclosed.class)
+public class TestWatcherTest {
+
+    @RunWith(Parameterized.class)
+    public static class Callbacks {
+
+        @Parameters(name = "{0}")
+        public static Object[][] parameters() {
+            return new Object[][] {
+                    {
+                        FailingTest.class,
+                        "starting failed finished ",
+                        asList("starting failed", "test failed", "failed failed", "finished failed") },
+                    {
+                        InternalViolatedAssumptionTest.class,
+                        "starting deprecated skipped finished ",
+                        asList("starting failed", "don't run", "deprecated skipped failed", "finished failed") },
+                    {
+                        SuccessfulTest.class,
+                        "starting succeeded finished ",
+                        asList("starting failed", "succeeded failed", "finished failed") },
+                    {
+                        ViolatedAssumptionTest.class,
+                        "starting skipped finished ",
+                        asList("starting failed", "Test could not be skipped due to other failures", "skipped failed", "finished failed") }
+            };
+        }
+
+        @Parameter(0)
+        public Class<?> testClass;
+
+        @Parameter(1)
+        public String expectedCallbacks;
+
+        @Parameter(2)
+        public List<String> expectedFailures;
+
+        private static TestRule selectedRule; //for injecting rule into test classes
+
+        @Test
+        public void correctCallbacksCalled() {
+            StringBuilder log = new StringBuilder();
+            selectedRule = new LoggingTestWatcher(log);
+            JUnitCore.runClasses(testClass);
+            assertEquals(expectedCallbacks, log.toString());
+        }
+
+        @Test
+        public void resultHasAllFailuresThrownByCallbacks() {
+            selectedRule = new ErroneousTestWatcher();
+            PrintableResult result = testResult(testClass);
+            assertThat(result, failureCountIs(expectedFailures.size()));
+            for (String expectedFailure: expectedFailures) {
+                assertThat(result, hasFailureContaining(expectedFailure));
+            }
+        }
+
+        @Test
+        public void testWatcherDoesNotModifyResult() {
+            selectedRule = new NoOpRule();
+            Result resultNoOpRule = JUnitCore.runClasses(testClass);
+            selectedRule = new LoggingTestWatcher(new StringBuilder());
+            Result resultTestWatcher = JUnitCore.runClasses(testClass);
+            assertEquals(
+                    "was successful",
+                    resultNoOpRule.wasSuccessful(),
+                    resultTestWatcher.wasSuccessful());
+            assertEquals(
+                    "failure count",
+                    resultNoOpRule.getFailureCount(),
+                    resultTestWatcher.getFailureCount());
+            assertEquals(
+                    "ignore count",
+                    resultNoOpRule.getIgnoreCount(),
+                    resultTestWatcher.getIgnoreCount());
+            assertEquals(
+                    "run count",
+                    resultNoOpRule.getRunCount(),
+                    resultTestWatcher.getRunCount());
+        }
+
+        private static class NoOpRule implements TestRule {
+            public Statement apply(Statement base, Description description) {
+                return base;
+            }
+        }
+
+        private static class ErroneousTestWatcher extends TestWatcher {
+            @Override
+            protected void succeeded(Description description) {
+                throw new RuntimeException("succeeded failed");
+            }
+
+            @Override
+            protected void failed(Throwable e, Description description) {
+                throw new RuntimeException("failed failed");
+            }
+
+            @Override
+            protected void skipped(org.junit.AssumptionViolatedException e, Description description) {
+                throw new RuntimeException("skipped failed");
+            }
+
+            @Override
+            @SuppressWarnings("deprecation")
+            protected void skipped(AssumptionViolatedException e, Description description) {
+                throw new RuntimeException("deprecated skipped failed");
+            }
+
+            @Override
+            protected void starting(Description description) {
+                throw new RuntimeException("starting failed");
+            }
+
+            @Override
+            protected void finished(Description description) {
+                throw new RuntimeException("finished failed");
+            }
+        }
+
+        public static class FailingTest {
+            @Rule
+            public TestRule rule = selectedRule;
+
+            @Test
+            public void test() {
+                fail("test failed");
+            }
+        }
+
+        public static class InternalViolatedAssumptionTest {
+            @Rule
+            public TestRule watcher = selectedRule;
+
+            @SuppressWarnings("deprecation")
+            @Test
+            public void test() {
+                throw new AssumptionViolatedException("don't run");
+            }
+        }
+
+        public static class SuccessfulTest {
+            @Rule
+            public TestRule watcher = selectedRule;
+
+            @Test
+            public void test() {
+            }
+        }
+
+        public static class ViolatedAssumptionTest {
+            @Rule
+            public TestRule watcher = selectedRule;
+
+            @Test
+            public void test() {
+                assumeTrue(false);
+            }
+        }
+    }
+
+    public static class CallbackArguments {
+
+        public static class Succeeded {
+            private static Description catchedDescription;
+
+            @Rule
+            public final TestRule watcher = new TestWatcher() {
+                @Override
+                protected void succeeded(Description description) {
+                    catchedDescription = description;
+                }
+            };
+
+            @Test
+            public void test() {
+            }
+        }
+
+        @Test
+        public void succeeded() {
+            JUnitCore.runClasses(Succeeded.class);
+            assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$Succeeded)",
+                    Succeeded.catchedDescription.getDisplayName());
+        }
+
+        public static class Failed {
+            private static Description catchedDescription;
+            private static Throwable catchedThrowable;
+
+            @Rule
+            public final TestRule watcher = new TestWatcher() {
+                @Override
+                protected void failed(Throwable e, Description description) {
+                    catchedDescription = description;
+                    catchedThrowable = e;
+                }
+            };
+
+            @Test
+            public void test() {
+                fail("test failed");
+            }
+        }
+
+        @Test
+        public void failed() {
+            JUnitCore.runClasses(Failed.class);
+            assertEquals("test failed", Failed.catchedThrowable.getMessage());
+            assertEquals(AssertionError.class, Failed.catchedThrowable.getClass());
+            assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$Failed)",
+                    Failed.catchedDescription.getDisplayName());
+        }
+
+        public static class Skipped {
+            private static Description catchedDescription;
+            private static org.junit.AssumptionViolatedException catchedException;
+
+            @Rule
+            public final TestRule watcher = new TestWatcher() {
+                @Override
+                protected void skipped(org.junit.AssumptionViolatedException e, Description description) {
+                    catchedDescription = description;
+                    catchedException = e;
+                }
+            };
+
+            @Test
+            public void test() {
+                assumeTrue("test skipped", false);
+            }
+        }
+
+        @Test
+        public void skipped() {
+            JUnitCore.runClasses(Skipped.class);
+            assertEquals("test skipped", Skipped.catchedException.getMessage());
+            assertEquals(org.junit.AssumptionViolatedException.class, Skipped.catchedException.getClass());
+            assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$Skipped)",
+                    Skipped.catchedDescription.getDisplayName());
+        }
+
+        public static class DeprecatedSkipped {
+            private static Description catchedDescription;
+            private static AssumptionViolatedException catchedException;
+
+            @Rule
+            public final TestRule watcher = new TestWatcher() {
+                @Override
+                @SuppressWarnings("deprecation")
+                protected void skipped(AssumptionViolatedException e, Description description) {
+                    catchedDescription = description;
+                    catchedException = e;
+                }
+            };
+
+            @SuppressWarnings("deprecation")
+            @Test
+            public void test() {
+                throw new AssumptionViolatedException("test skipped");
+            }
+        }
+
+        @Test
+        public void deprecatedSkipped() {
+            JUnitCore.runClasses(DeprecatedSkipped.class);
+            assertEquals("test skipped", DeprecatedSkipped.catchedException.getMessage());
+            assertEquals(AssumptionViolatedException.class, DeprecatedSkipped.catchedException.getClass());
+            assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$DeprecatedSkipped)",
+                    DeprecatedSkipped.catchedDescription.getDisplayName());
+        }
+
+        public static class Starting {
+            private static Description catchedDescription;
+
+            @Rule
+            public final TestRule watcher = new TestWatcher() {
+                @Override
+                protected void starting(Description description) {
+                    catchedDescription = description;
+                }
+            };
+
+            @Test
+            public void test() {
+            }
+        }
+
+        @Test
+        public void starting() {
+            JUnitCore.runClasses(Starting.class);
+            assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$Starting)",
+                    Starting.catchedDescription.getDisplayName());
+        }
+
+        public static class Finished {
+            private static Description catchedDescription;
+
+            @Rule
+            public final TestRule watcher = new TestWatcher() {
+                @Override
+                protected void finished(Description description) {
+                    catchedDescription = description;
+                }
+            };
+
+            @Test
+            public void test() {
+            }
+        }
+
+        @Test
+        public void finished() {
+            JUnitCore.runClasses(Finished.class);
+            assertEquals("test(org.junit.rules.TestWatcherTest$CallbackArguments$Finished)",
+                    Finished.catchedDescription.getDisplayName());
+        }
+    }
+
+    //The following tests check the information in TestWatcher's Javadoc
+    //regarding interplay with other rules.
+    public static class InterplayWithOtherRules {
+        private static StringBuilder log;
+
+        public static class ExpectedExceptionTest {
+            @Rule(order = Integer.MIN_VALUE)
+            //the field name must be alphabetically lower than "thrown" in order
+            //to make the test failing if order is not set
+            public final TestRule a = new LoggingTestWatcher(log);
+
+            @Rule
+            public final ExpectedException thrown = none();
+
+            @Test
+            public void testWithExpectedException() {
+                thrown.expect(RuntimeException.class);
+                throw new RuntimeException("expected exception");
+            }
+        }
+
+        @Test
+        public void expectedExceptionIsSeenAsSuccessfulTest() {
+            log = new StringBuilder();
+            JUnitCore.runClasses(ExpectedExceptionTest.class);
+            assertEquals("starting succeeded finished ", log.toString());
+        }
+
+        public static class ErrorCollectorTest {
+            @Rule(order = Integer.MIN_VALUE)
+            //the field name must be alphabetically lower than "collector" in
+            //order to make the test failing if order is not set
+            public final TestRule a = new LoggingTestWatcher(log);
+
+            @Rule
+            public final ErrorCollector collector = new ErrorCollector();
+
+            @Test
+            public void test() {
+                collector.addError(new RuntimeException("expected exception"));
+            }
+        }
+
+        @Test
+        public void testIsSeenAsFailedBecauseOfCollectedError() {
+            log = new StringBuilder();
+            JUnitCore.runClasses(ErrorCollectorTest.class);
+            assertEquals("starting failed finished ", log.toString());
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/TestWatchmanTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/TestWatchmanTest.java
new file mode 100644
index 0000000..b7b76be
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/TestWatchmanTest.java
@@ -0,0 +1,90 @@
+package org.junit.rules;
+
+import static junit.framework.Assert.fail;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeTrue;
+import static org.junit.runner.JUnitCore.runClasses;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runners.model.FrameworkMethod;
+
+@SuppressWarnings("deprecation")
+public class TestWatchmanTest {
+    public static class ViolatedAssumptionTest {
+        static StringBuilder log;
+
+        @BeforeClass
+        public static void initLog() {
+            log = new StringBuilder();
+        }
+
+        @Rule
+        public LoggingTestWatchman watchman = new LoggingTestWatchman(log);
+
+        @Test
+        public void succeeds() {
+            assumeTrue(false);
+        }
+    }
+
+    @Test
+    public void neitherLogSuccessNorFailedForViolatedAssumption() {
+        runClasses(ViolatedAssumptionTest.class);
+        assertThat(ViolatedAssumptionTest.log.toString(),
+                is("starting finished "));
+    }
+
+    public static class FailingTest {
+        static StringBuilder log;
+
+        @BeforeClass
+        public static void initLog() {
+            log = new StringBuilder();
+        }
+
+        @Rule
+        public LoggingTestWatchman watchman = new LoggingTestWatchman(log);
+
+        @Test
+        public void succeeds() {
+            fail();
+        }
+    }
+
+    @Test
+    public void logFailingTest() {
+        runClasses(FailingTest.class);
+        assertThat(FailingTest.log.toString(),
+                is("starting failed finished "));
+    }
+
+    private static class LoggingTestWatchman extends TestWatchman {
+        private final StringBuilder log;
+
+        private LoggingTestWatchman(StringBuilder log) {
+            this.log = log;
+        }
+
+        @Override
+        public void succeeded(FrameworkMethod method) {
+            log.append("succeeded ");
+        }
+
+        @Override
+        public void failed(Throwable e, FrameworkMethod method) {
+            log.append("failed ");
+        }
+
+        @Override
+        public void starting(FrameworkMethod method) {
+            log.append("starting ");
+        }
+
+        @Override
+        public void finished(FrameworkMethod method) {
+            log.append("finished ");
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/TimeoutRuleTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/TimeoutRuleTest.java
new file mode 100644
index 0000000..6c0e349
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/TimeoutRuleTest.java
@@ -0,0 +1,162 @@
+package org.junit.rules;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+
+public class TimeoutRuleTest {
+    private static final ReentrantLock run1Lock = new ReentrantLock();
+
+    private static volatile boolean run4done = false;
+
+    public abstract static class AbstractTimeoutTest {
+        public static final StringBuffer logger = new StringBuffer();
+
+        @Rule
+        public final TemporaryFolder tmpFile = new TemporaryFolder();
+
+        @Test
+        public void run1() throws InterruptedException {
+            logger.append("run1");
+            TimeoutRuleTest.run1Lock.lockInterruptibly();
+            TimeoutRuleTest.run1Lock.unlock();
+        }
+
+        @Test
+        public void run2() throws InterruptedException {
+            logger.append("run2");
+            Thread.currentThread().join();
+        }
+
+        @Test
+        public synchronized void run3() throws InterruptedException {
+            logger.append("run3");
+            wait();
+        }
+
+        @Test
+        public void run4() {
+            logger.append("run4");
+            while (!run4done) {
+            }
+        }
+
+        @Test
+        public void run5() throws IOException {
+            logger.append("run5");
+            Random rnd = new Random();
+            byte[] data = new byte[1024];
+            File tmp = tmpFile.newFile();
+            while (true) {
+                RandomAccessFile randomAccessFile = new RandomAccessFile(tmp, "rw");
+                try {
+                    FileChannel channel = randomAccessFile.getChannel();
+                    rnd.nextBytes(data);
+                    ByteBuffer buffer = ByteBuffer.wrap(data);
+                    // Interrupted thread closes channel and throws ClosedByInterruptException.
+                    channel.write(buffer);
+                } finally {
+                    randomAccessFile.close();
+                }
+                tmp.delete();
+            }
+        }
+
+        @Test
+        public void run6() throws InterruptedIOException {
+            logger.append("run6");
+            // Java IO throws InterruptedIOException only on SUN machines.
+            throw new InterruptedIOException();
+        }
+    }
+
+    public static class HasGlobalLongTimeout extends AbstractTimeoutTest {
+
+        @Rule
+        public final TestRule globalTimeout = Timeout.millis(200);
+    }
+
+    public static class HasGlobalTimeUnitTimeout extends AbstractTimeoutTest {
+
+        @Rule
+        public final TestRule globalTimeout = new Timeout(200, TimeUnit.MILLISECONDS);
+    }
+    
+    public static class HasNullTimeUnit {
+
+        @Rule
+        public final TestRule globalTimeout = new Timeout(200, null);
+        
+        @Test
+        public void wouldPass() {
+        }
+    }
+
+    @Before
+    public void before() {
+        run4done = false;
+        run1Lock.lock();
+    }
+
+    @After
+    public void after() {
+        // set run4done to make sure that the thread won't continue at run4()
+        run4done = true;
+        run1Lock.unlock();
+    }
+
+    @Test
+    public void timeUnitTimeout() {
+        HasGlobalTimeUnitTimeout.logger.setLength(0);
+        Result result = JUnitCore.runClasses(HasGlobalTimeUnitTimeout.class);
+        assertEquals(6, result.getFailureCount());
+        assertThat(HasGlobalTimeUnitTimeout.logger.toString(), containsString("run1"));
+        assertThat(HasGlobalTimeUnitTimeout.logger.toString(), containsString("run2"));
+        assertThat(HasGlobalTimeUnitTimeout.logger.toString(), containsString("run3"));
+        assertThat(HasGlobalTimeUnitTimeout.logger.toString(), containsString("run4"));
+        assertThat(HasGlobalTimeUnitTimeout.logger.toString(), containsString("run5"));
+        assertThat(HasGlobalTimeUnitTimeout.logger.toString(), containsString("run6"));
+    }
+
+    @Test
+    public void longTimeout() {
+        HasGlobalLongTimeout.logger.setLength(0);
+        Result result = JUnitCore.runClasses(HasGlobalLongTimeout.class);
+        assertEquals(6, result.getFailureCount());
+        assertThat(HasGlobalLongTimeout.logger.toString(), containsString("run1"));
+        assertThat(HasGlobalLongTimeout.logger.toString(), containsString("run2"));
+        assertThat(HasGlobalLongTimeout.logger.toString(), containsString("run3"));
+        assertThat(HasGlobalLongTimeout.logger.toString(), containsString("run4"));
+        assertThat(HasGlobalLongTimeout.logger.toString(), containsString("run5"));
+        assertThat(HasGlobalLongTimeout.logger.toString(), containsString("run6"));
+    }
+
+    @Test
+    public void nullTimeUnit() {
+        Result result = JUnitCore.runClasses(HasNullTimeUnit.class);
+        assertEquals(1, result.getFailureCount());
+        Failure failure = result.getFailures().get(0);
+        assertThat(failure.getException().getMessage(),
+                containsString("Invalid parameters for Timeout"));
+        Throwable cause = failure.getException().getCause();
+        assertThat(cause.getMessage(), containsString("TimeUnit cannot be null"));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/rules/VerifierRuleTest.java b/google3/third_party/java_src/junit/test/java/org/junit/rules/VerifierRuleTest.java
new file mode 100644
index 0000000..4a09bc7
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/rules/VerifierRuleTest.java
@@ -0,0 +1,36 @@
+package org.junit.rules;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import org.junit.Rule;
+import org.junit.Test;
+
+public class VerifierRuleTest {
+
+    private static String sequence;
+
+    public static class UsesVerifier {
+        @Rule
+        public Verifier collector = new Verifier() {
+            @Override
+            protected void verify() {
+                sequence += "verify ";
+            }
+        };
+
+        @Test
+        public void example() {
+            sequence += "test ";
+        }
+    }
+
+    @Test
+    public void verifierRunsAfterTest() {
+        sequence = "";
+        assertThat(testResult(UsesVerifier.class), isSuccessful());
+        assertEquals("test verify ", sequence);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/AllRunnerTests.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/AllRunnerTests.java
new file mode 100644
index 0000000..3334b40
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/AllRunnerTests.java
@@ -0,0 +1,18 @@
+package org.junit.runner;
+
+
+import org.junit.runner.notification.AllNotificationTests;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AllNotificationTests.class,
+        FilterFactoriesTest.class,
+        FilterOptionIntegrationTest.class,
+        OrderWithValidatorTest.class,
+        JUnitCommandLineParseResultTest.class,
+        JUnitCoreTest.class, RequestTest.class
+})
+public class AllRunnerTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/FilterFactoriesTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/FilterFactoriesTest.java
new file mode 100644
index 0000000..c00efde
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/FilterFactoriesTest.java
@@ -0,0 +1,137 @@
+package org.junit.runner;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeThat;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.ExcludeCategories;
+import org.junit.rules.ExpectedException;
+import org.junit.rules.TestName;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+public class FilterFactoriesTest {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Rule
+    public TestName testName = new TestName();
+
+    private Request createSuiteRequest() {
+        return Request.aClass(DummySuite.class);
+    }
+
+    @Test
+    public void shouldCreateFilterWithArguments() throws Exception {
+        Filter filter = FilterFactories.createFilterFromFilterSpec(
+                createSuiteRequest(),
+                ExcludeCategories.class.getName() + "=" + DummyCategory.class.getName());
+
+        assertThat(filter.describe(), startsWith("excludes "));
+    }
+
+    @Test
+    public void shouldCreateFilterWithNoArguments() throws Exception {
+        Filter filter = FilterFactories.createFilterFromFilterSpec(
+                createSuiteRequest(), FilterFactoryStub.class.getName());
+
+        assertThat(filter, instanceOf(DummyFilter.class));
+    }
+
+    @Test
+    public void shouldPassOnDescriptionToFilterFactory() throws Exception {
+        Request request = createSuiteRequest();
+        Description description = request.getRunner().getDescription();
+        Filter filter = FilterFactories.createFilterFromFilterSpec(
+                request, FilterFactoryStub.class.getName());
+
+        // This assumption tested in shouldCreateFilterWithNoArguments()
+        assumeThat(filter, instanceOf(DummyFilter.class));
+
+        DummyFilter dummyFilter = (DummyFilter) filter;
+        assertThat(dummyFilter.getTopLevelDescription(), is(description));
+    }
+
+    @Test
+    public void shouldCreateFilter() throws Exception {
+        Filter filter = FilterFactories.createFilter(
+                FilterFactoryStub.class,
+                new FilterFactoryParams(
+                        Description.createSuiteDescription(testName.getMethodName()),
+                        ""));
+
+        assertThat(filter, instanceOf(DummyFilter.class));
+    }
+
+    @Test
+    public void shouldThrowExceptionIfNotFilterFactory() throws Exception {
+        expectedException.expect(FilterFactory.FilterNotCreatedException.class);
+
+        FilterFactories.createFilterFactory(NonFilterFactory.class.getName());
+    }
+
+    @Test
+    public void shouldThrowExceptionIfNotInstantiable() throws Exception {
+        expectedException.expect(FilterFactory.FilterNotCreatedException.class);
+
+        FilterFactories.createFilterFactory(NonInstantiableFilterFactory.class);
+    }
+
+    public static class NonFilterFactory {
+    }
+
+    public static class NonInstantiableFilterFactory implements FilterFactory {
+        private NonInstantiableFilterFactory() {
+        }
+
+        public Filter createFilter(FilterFactoryParams params) throws FilterNotCreatedException {
+            throw new FilterNotCreatedException(new Exception("not implemented"));
+        }
+    }
+
+    public static class FilterFactoryStub implements FilterFactory {
+        public Filter createFilter(FilterFactoryParams params) {
+            return new DummyFilter(params.getTopLevelDescription());
+        }
+    }
+
+    private static class DummyFilter extends Filter {
+        private final Description fTopLevelDescription;
+
+        public DummyFilter(Description topLevelDescription) {
+            fTopLevelDescription = topLevelDescription;
+        }
+
+        public Description getTopLevelDescription() {
+            return fTopLevelDescription;
+        }
+
+        @Override
+        public boolean shouldRun(Description description) {
+            return false;
+        }
+
+        @Override
+        public String describe() {
+            return null;
+        }
+    }
+
+    public static class DummyCategory {
+    }
+
+    @RunWith(Suite.class)
+    @SuiteClasses(DummyTest.class)
+    public static class DummySuite {
+    }
+
+    public static class DummyTest {
+        @Test
+        public void passes() {
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/FilterOptionIntegrationTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/FilterOptionIntegrationTest.java
new file mode 100644
index 0000000..25cde87
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/FilterOptionIntegrationTest.java
@@ -0,0 +1,190 @@
+package org.junit.runner;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.experimental.categories.ExcludeCategories;
+import org.junit.experimental.categories.IncludeCategories;
+import org.junit.runner.notification.RunListener;
+import org.junit.tests.TestSystem;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class FilterOptionIntegrationTest {
+    private static final String INCLUDES_DUMMY_CATEGORY_0 = "--filter=" +
+            IncludeCategories.class.getName() + "=" + DummyCategory0.class.getName();
+    private static final String EXCLUDES_DUMMY_CATEGORY_1 = "--filter=" +
+            ExcludeCategories.class.getName() + "=" + DummyCategory1.class.getName();
+
+    private JUnitCore jUnitCore = new JUnitCore();
+    private TestListener testListener = new TestListener();
+
+    @Before
+    public void setUp() {
+        jUnitCore.addListener(testListener);
+    }
+
+    @Test
+    public void shouldRunAllTests() {
+        Result result = runJUnit(
+                DummyTestClass.class.getName(),
+                DummyTestClass0.class.getName(),
+                DummyTestClass1.class.getName(),
+                DummyTestClass01.class.getName(),
+                DummyTestClass0TestMethod1.class.getName());
+
+        assertWasRun(DummyTestClass.class);
+        assertWasRun(DummyTestClass0.class);
+        assertWasRun(DummyTestClass1.class);
+        assertWasRun(DummyTestClass01.class);
+        assertWasRun(DummyTestClass0TestMethod1.class);
+        assertThat("runCount does not match", result.getRunCount(), is(5));
+        assertThat("failureCount does not match", result.getFailureCount(), is(0));
+    }
+
+    @Test
+    public void shouldExcludeSomeTests() {
+        Result result = runJUnit(
+                EXCLUDES_DUMMY_CATEGORY_1,
+                DummyTestClass.class.getName(),
+                DummyTestClass0.class.getName(),
+                DummyTestClass1.class.getName(),
+                DummyTestClass01.class.getName(),
+                DummyTestClass0TestMethod1.class.getName());
+
+        assertWasRun(DummyTestClass.class);
+        assertWasRun(DummyTestClass0.class);
+        assertWasNotRun(DummyTestClass1.class);
+        assertWasNotRun(DummyTestClass01.class);
+        assertWasNotRun(DummyTestClass0TestMethod1.class);
+        assertThat("runCount does not match", result.getRunCount(), is(2));
+        assertThat("failureCount does not match", result.getFailureCount(), is(0));
+    }
+
+    @Test
+    public void shouldIncludeSomeTests() {
+        Result result = runJUnit(
+                INCLUDES_DUMMY_CATEGORY_0,
+                DummyTestClass.class.getName(),
+                DummyTestClass0.class.getName(),
+                DummyTestClass1.class.getName(),
+                DummyTestClass01.class.getName(),
+                DummyTestClass0TestMethod1.class.getName());
+
+        assertWasNotRun(DummyTestClass.class);
+        assertWasRun(DummyTestClass0.class);
+        assertWasNotRun(DummyTestClass1.class);
+        assertWasRun(DummyTestClass01.class);
+        assertWasRun(DummyTestClass0TestMethod1.class);
+        assertThat("runCount does not match", result.getRunCount(), is(3));
+        assertThat("failureCount does not match", result.getFailureCount(), is(0));
+    }
+
+    @Test
+    public void shouldCombineFilters() {
+        Result result = runJUnit(
+                INCLUDES_DUMMY_CATEGORY_0,
+                EXCLUDES_DUMMY_CATEGORY_1,
+                DummyTestClass.class.getName(),
+                DummyTestClass0.class.getName(),
+                DummyTestClass1.class.getName(),
+                DummyTestClass01.class.getName(),
+                DummyTestClass0TestMethod1.class.getName());
+
+        assertWasNotRun(DummyTestClass.class);
+        assertWasRun(DummyTestClass0.class);
+        assertWasNotRun(DummyTestClass1.class);
+        assertWasNotRun(DummyTestClass01.class);
+        assertWasNotRun(DummyTestClass0TestMethod1.class);
+        assertThat("runCount does not match", result.getRunCount(), is(1));
+        assertThat("failureCount does not match", result.getFailureCount(), is(0));
+    }
+
+    private Result runJUnit(final String... args) {
+        return jUnitCore.runMain(new TestSystem(), args);
+    }
+
+    private void assertWasRun(Class<?> testClass) {
+        assertTrue(testClass.getName() + " expected to finish but did not", testListener.wasRun(testClass));
+    }
+
+    private void assertWasNotRun(Class<?> testClass) {
+        assertFalse(
+                testClass.getName() + " expected not to have been started but was",
+                testListener.wasRun(testClass));
+    }
+
+    private static class TestListener extends RunListener {
+        private Set<String> startedTests = new HashSet<String>();
+        private Set<String> finishedTests = new HashSet<String>();
+
+        @Override
+        public void testFinished(final Description description) {
+            finishedTests.add(description.getClassName());
+        }
+
+        private boolean testFinished(final Class<?> testClass) {
+            return finishedTests.contains(testClass.getName());
+        }
+
+        @Override
+        public void testStarted(final Description description) {
+            startedTests.add(description.getClassName());
+        }
+
+        private boolean testStarted(final Class<?> testClass) {
+            return startedTests.contains(testClass.getName());
+        }
+
+        public boolean wasRun(final Class<?> testClass) {
+            return testStarted(testClass) && testFinished(testClass);
+        }
+    }
+
+    public static class DummyTestClass {
+        @Test
+        public void dummyTest() {
+        }
+    }
+
+    @Category(DummyCategory0.class)
+    public static class DummyTestClass0 {
+        @Test
+        public void dummyTest() {
+        }
+    }
+
+    @Category(DummyCategory1.class)
+    public static class DummyTestClass1 {
+        @Test
+        public void dummyTest() {
+        }
+    }
+
+    @Category({DummyCategory0.class, DummyCategory1.class})
+    public static class DummyTestClass01 {
+        @Test
+        public void dummyTest() {
+        }
+    }
+
+    @Category(DummyCategory0.class)
+    public static class DummyTestClass0TestMethod1 {
+        @Category(DummyCategory1.class)
+        @Test
+        public void dummyTest() {
+        }
+    }
+
+    public static interface DummyCategory0 {
+    }
+
+    public static interface DummyCategory1 {
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/JUnitCommandLineParseResultTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/JUnitCommandLineParseResultTest.java
new file mode 100644
index 0000000..065f7bf
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/JUnitCommandLineParseResultTest.java
@@ -0,0 +1,146 @@
+package org.junit.runner;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.hasItems;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.IncludeCategories;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.manipulation.Filter;
+
+public class JUnitCommandLineParseResultTest {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    private final JUnitCommandLineParseResult jUnitCommandLineParseResult = new JUnitCommandLineParseResult();
+
+    @Test
+    public void shouldStopParsingOptionsUponDoubleHyphenArg() throws Exception {
+        String[] restOfArgs = jUnitCommandLineParseResult.parseOptions(
+                "--0", "--1", "--", "--2", "--3");
+
+        assertThat(restOfArgs, is(new String[]{"--2", "--3"}));
+    }
+
+    @Test
+    public void shouldParseFilterArgWithEqualsSyntax() throws Exception {
+        String value= IncludeCategories.class.getName() + "=" + DummyCategory0.class.getName();
+        jUnitCommandLineParseResult.parseOptions("--filter=" + value);
+
+        List<String> specs= jUnitCommandLineParseResult.getFilterSpecs();
+
+        assertThat(specs, hasItems(value));
+    }
+
+    @Test
+    public void shouldCreateFailureUponBaldFilterOptionNotFollowedByValue() {
+        jUnitCommandLineParseResult.parseOptions("--filter");
+
+        Runner runner = jUnitCommandLineParseResult.createRequest(new Computer()).getRunner();
+        Description description = runner.getDescription().getChildren().get(0);
+
+        assertThat(description.toString(), containsString("initializationError"));
+    }
+
+    @Test
+    public void shouldParseFilterArgInWhichValueIsASeparateArg() throws Exception {
+        String value= IncludeCategories.class.getName() + "=" + DummyCategory0.class.getName();
+        jUnitCommandLineParseResult.parseOptions("--filter", value);
+
+        List<String> specs= jUnitCommandLineParseResult.getFilterSpecs();
+
+        assertThat(specs, hasItems(value));
+    }
+
+    @Test
+    public void shouldStopParsingOptionsUponNonOption() throws Exception {
+        String[] restOfArgs = jUnitCommandLineParseResult.parseOptions(new String[]{
+                "--0", "--1", "2", "3"
+        });
+
+        assertThat(restOfArgs, is(new String[]{"2", "3"}));
+    }
+
+    @Test
+    public void shouldCreateFailureUponUnknownOption() throws Exception {
+        String unknownOption = "--unknown-option";
+        jUnitCommandLineParseResult.parseOptions(new String[]{
+                unknownOption
+        });
+
+        Runner runner = jUnitCommandLineParseResult.createRequest(new Computer()).getRunner();
+        Description description = runner.getDescription().getChildren().get(0);
+
+        assertThat(description.toString(), containsString("initializationError"));
+    }
+
+    @Test
+    public void shouldCreateFailureUponUncreatedFilter() throws Exception {
+        jUnitCommandLineParseResult.parseOptions(new String[]{
+                "--filter=" + FilterFactoryStub.class.getName()
+        });
+
+        Runner runner = jUnitCommandLineParseResult.createRequest(new Computer()).getRunner();
+        Description description = runner.getDescription().getChildren().get(0);
+
+        assertThat(description.toString(), containsString("initializationError"));
+    }
+
+    @Test
+    public void shouldCreateFailureUponUnfoundFilterFactory() throws Exception {
+        String nonExistentFilterFactory = "NonExistentFilterFactory";
+        jUnitCommandLineParseResult.parseOptions(new String[]{
+                "--filter=" + nonExistentFilterFactory
+        });
+
+        Runner runner = jUnitCommandLineParseResult.createRequest(new Computer()).getRunner();
+        Description description = runner.getDescription().getChildren().get(0);
+
+        assertThat(description.toString(), containsString("initializationError"));
+    }
+
+    @Test
+    public void shouldAddToClasses() {
+        jUnitCommandLineParseResult.parseParameters(new String[]{
+                DummyTest.class.getName()
+        });
+
+        List<Class<?>> classes = jUnitCommandLineParseResult.getClasses();
+        Class<?> testClass = classes.get(0);
+
+        assertThat(testClass.getName(), is(DummyTest.class.getName()));
+    }
+
+    @Test
+    public void shouldCreateFailureUponUnknownTestClass() throws Exception {
+        String unknownTestClass = "UnknownTestClass";
+        jUnitCommandLineParseResult.parseParameters(new String[]{
+                unknownTestClass
+        });
+
+        Runner runner = jUnitCommandLineParseResult.createRequest(new Computer()).getRunner();
+        Description description = runner.getDescription().getChildren().get(0);
+
+        assertThat(description.toString(), containsString("initializationError"));
+    }
+
+    public static class FilterFactoryStub implements FilterFactory {
+        public Filter createFilter(FilterFactoryParams params) throws FilterNotCreatedException {
+            throw new FilterNotCreatedException(new Exception("stub"));
+        }
+    }
+
+    public static interface DummyCategory0 {
+    }
+
+    public static class DummyTest {
+        @Test
+        public void dummyTest() {
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/JUnitCoreTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/JUnitCoreTest.java
new file mode 100644
index 0000000..2c5e408
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/JUnitCoreTest.java
@@ -0,0 +1,20 @@
+package org.junit.runner;
+
+import org.junit.Test;
+import org.junit.tests.TestSystem;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class JUnitCoreTest {
+    @Test
+    public void shouldAddFailuresToResult() {
+        JUnitCore jUnitCore = new JUnitCore();
+
+        Result result = jUnitCore.runMain(new TestSystem(), "NonExistentTest");
+
+        assertThat(result.getFailureCount(), is(1));
+        assertThat(result.getFailures().get(0).getException(), instanceOf(IllegalArgumentException.class));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/OrderWithValidatorTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/OrderWithValidatorTest.java
new file mode 100644
index 0000000..cfa3c5e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/OrderWithValidatorTest.java
@@ -0,0 +1,50 @@
+package org.junit.runner;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.List;
+
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.manipulation.Alphanumeric;
+import org.junit.runners.JUnit4;
+import org.junit.runners.MethodSorters;
+import org.junit.runners.model.TestClass;
+
+public class OrderWithValidatorTest {
+    private final OrderWithValidator validator = new OrderWithValidator();
+
+    @RunWith(JUnit4.class)
+    @OrderWith(Alphanumeric.class)
+    public static class TestWithNoValidationErrors {
+        @Test
+        public void passes() {}
+    }
+
+    @RunWith(JUnit4.class)
+    @OrderWith(Alphanumeric.class)
+    @FixMethodOrder(MethodSorters.NAME_ASCENDING)
+    public static class TestAnnotatedWithFixMethodOrder {
+        @Test
+        public void passes() {}
+    }
+
+    @Test
+    public void noErrorIsAddedForTestWithoutValdationErrors() {
+        List<Exception> errors = validator.validateAnnotatedClass(
+                new TestClass(TestWithNoValidationErrors.class));
+        
+        assertThat(errors.size(), is(0));
+    }
+ 
+    @Test
+    public void errorIsAddedWhenTestAnnotatedWithFixMethodOrder() {
+        List<Exception> errors = validator.validateAnnotatedClass(
+                new TestClass(TestAnnotatedWithFixMethodOrder.class));
+        
+        assertThat(errors.size(), is(1));
+        Exception exception = errors.get(0);
+        assertThat(exception.getMessage(), is("@FixMethodOrder cannot be combined with @OrderWith"));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/RequestTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/RequestTest.java
new file mode 100644
index 0000000..dc6a811
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/RequestTest.java
@@ -0,0 +1,50 @@
+package org.junit.runner;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.rules.EventCollector.hasSingleFailureWithMessage;
+
+import org.junit.Test;
+import org.junit.rules.EventCollector;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.RunnerBuilder;
+
+public class RequestTest {
+
+    /**
+     * #1320 A root of a {@link Description} produced by
+     * {@link Request#classes(Class...)} should be named "classes"
+     */
+    @Test
+    public void createsADescriptionWithANameForClasses() {
+        Description description = Request
+                .classes(RequestTest.class, RequestTest.class).getRunner()
+                .getDescription();
+        assertThat(description.toString(), is("classes"));
+    }
+
+    @Test
+    public void reportsInitializationErrorThrownWhileCreatingSuite() {
+        EventCollector collector = new EventCollector();
+        JUnitCore core = new JUnitCore();
+        core.addListener(collector);
+
+        core.run(new FailingComputer(), FooTest.class, BarTest.class);
+
+        assertThat(collector, hasSingleFailureWithMessage("cannot create suite"));
+    }
+
+    private static class FailingComputer extends Computer {
+        @Override
+        public Runner getSuite(RunnerBuilder builder, Class<?>[] classes)
+                throws InitializationError {
+            throw new InitializationError("cannot create suite");
+        }
+    }
+
+    private static class FooTest {
+    }
+
+    private static class BarTest {
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/RunnerSpy.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/RunnerSpy.java
new file mode 100644
index 0000000..939cd75
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/RunnerSpy.java
@@ -0,0 +1,37 @@
+package org.junit.runner;
+
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.model.RunnerBuilder;
+
+public class RunnerSpy extends Runner {
+    public static final Description DESCRIPTION = Description.TEST_MECHANISM;
+
+    private RunnerBuilder invokedRunnerBuilder;
+    private Class<?> invokedTestClass;
+
+    public RunnerSpy(Class<?> testClass) {
+        invokedTestClass = testClass;
+    }
+
+    public RunnerSpy(Class<?> testClass, RunnerBuilder runnerBuilder) {
+        invokedTestClass = testClass;
+        invokedRunnerBuilder = runnerBuilder;
+    }
+
+    @Override
+    public Description getDescription() {
+        return DESCRIPTION;
+    }
+
+    @Override
+    public void run(RunNotifier runNotifier) {
+    }
+
+    public RunnerBuilder getInvokedRunnerBuilder() {
+        return invokedRunnerBuilder;
+    }
+
+    public Class<?> getInvokedTestClass() {
+        return invokedTestClass;
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/AllNotificationTests.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/AllNotificationTests.java
new file mode 100644
index 0000000..1c991a9
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/AllNotificationTests.java
@@ -0,0 +1,14 @@
+package org.junit.runner.notification;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        ConcurrentRunNotifierTest.class,
+        RunNotifierTest.class,
+        SynchronizedRunListenerTest.class
+})
+public class AllNotificationTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/ConcurrentRunNotifierTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/ConcurrentRunNotifierTest.java
new file mode 100644
index 0000000..b7386e3
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/ConcurrentRunNotifierTest.java
@@ -0,0 +1,180 @@
+package org.junit.runner.notification;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+
+import java.util.Random;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Testing RunNotifier in concurrent access.
+ *
+ * @author Tibor Digana (tibor17)
+ * @version 4.12
+ * @since 4.12
+ */
+public final class ConcurrentRunNotifierTest {
+    private static final long TIMEOUT = 3;
+    private final RunNotifier fNotifier = new RunNotifier();
+
+    private static class ConcurrentRunListener extends RunListener {
+        final AtomicInteger fTestStarted = new AtomicInteger(0);
+
+        @Override
+        public void testStarted(Description description) throws Exception {
+            fTestStarted.incrementAndGet();
+        }
+    }
+
+    @Test
+    public void realUsage() throws Exception {
+        ConcurrentRunListener listener1 = new ConcurrentRunListener();
+        ConcurrentRunListener listener2 = new ConcurrentRunListener();
+        fNotifier.addListener(listener1);
+        fNotifier.addListener(listener2);
+
+        final int numParallelTests = 4;
+        ExecutorService pool = Executors.newFixedThreadPool(numParallelTests);
+        for (int i = 0; i < numParallelTests; ++i) {
+            pool.submit(new Runnable() {
+                public void run() {
+                    fNotifier.fireTestStarted(null);
+                }
+            });
+        }
+        pool.shutdown();
+        assertTrue(pool.awaitTermination(TIMEOUT, TimeUnit.SECONDS));
+
+        fNotifier.removeListener(listener1);
+        fNotifier.removeListener(listener2);
+
+        assertThat(listener1.fTestStarted.get(), is(numParallelTests));
+        assertThat(listener2.fTestStarted.get(), is(numParallelTests));
+    }
+
+    private static class ExaminedListener extends RunListener {
+        final boolean throwFromTestStarted;
+        volatile boolean hasTestFailure = false;
+
+        ExaminedListener(boolean throwFromTestStarted) {
+            this.throwFromTestStarted = throwFromTestStarted;
+        }
+
+        @Override
+        public void testStarted(Description description) throws Exception {
+            if (throwFromTestStarted) {
+                throw new Exception();
+            }
+        }
+
+        @Override
+        public void testFailure(Failure failure) throws Exception {
+            hasTestFailure = true;
+        }
+    }
+
+    private abstract class AbstractConcurrentFailuresTest {
+
+        protected abstract void addListener(ExaminedListener listener);
+
+        public void test() throws Exception {
+            int totalListenersFailures = 0;
+
+            Random random = new Random(42);
+            ExaminedListener[] examinedListeners = new ExaminedListener[1000];
+            for (int i = 0; i < examinedListeners.length; ++i) {
+                boolean fail = random.nextDouble() >= 0.5d;
+                if (fail) {
+                    ++totalListenersFailures;
+                }
+                examinedListeners[i] = new ExaminedListener(fail);
+            }
+
+            final AtomicBoolean condition = new AtomicBoolean(true);
+            final CyclicBarrier trigger = new CyclicBarrier(2);
+            final CountDownLatch latch = new CountDownLatch(10);
+
+            ExecutorService notificationsPool = Executors.newFixedThreadPool(4);
+            notificationsPool.submit(new Callable<Void>() {
+                public Void call() throws Exception {
+                    trigger.await();
+                    while (condition.get()) {
+                        fNotifier.fireTestStarted(null);
+                        latch.countDown();
+                    }
+                    fNotifier.fireTestStarted(null);
+                    return null;
+                }
+            });
+
+            // Wait for callable to start
+            trigger.await(TIMEOUT, TimeUnit.SECONDS);
+
+            // Wait for callable to fire a few events
+            latch.await(TIMEOUT, TimeUnit.SECONDS);
+
+            for (ExaminedListener examinedListener : examinedListeners) {
+              addListener(examinedListener);
+            }
+
+            notificationsPool.shutdown();
+            condition.set(false);
+            assertTrue(notificationsPool.awaitTermination(TIMEOUT, TimeUnit.SECONDS));
+
+            if (totalListenersFailures != 0) {
+                // If no listener failures, then all the listeners do not report any failure.
+                int countTestFailures = examinedListeners.length - countReportedTestFailures(examinedListeners);
+                assertThat(totalListenersFailures, is(countTestFailures));
+            }
+        }
+    }
+
+    /**
+     * Verifies that listeners added while tests are run concurrently are
+     * notified about test failures.
+     */
+    @Test
+    public void reportConcurrentFailuresAfterAddListener() throws Exception {
+        new AbstractConcurrentFailuresTest() {
+            @Override
+            protected void addListener(ExaminedListener listener) {
+                fNotifier.addListener(listener);
+            }
+        }.test();
+    }
+
+    /**
+     * Verifies that listeners added with addFirstListener() while tests are run concurrently are
+     * notified about test failures.
+     */
+    @Test
+    public void reportConcurrentFailuresAfterAddFirstListener() throws Exception {
+        new AbstractConcurrentFailuresTest() {
+            @Override
+            protected void addListener(ExaminedListener listener) {
+                fNotifier.addFirstListener(listener);
+            }
+        }.test();
+    }
+
+    private static int countReportedTestFailures(ExaminedListener[] listeners) {
+        int count = 0;
+        for (ExaminedListener listener : listeners) {
+            if (listener.hasTestFailure) {
+                ++count;
+            }
+        }
+        return count;
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/RunNotifierTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/RunNotifierTest.java
new file mode 100644
index 0000000..c3a4a88
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/RunNotifierTest.java
@@ -0,0 +1,131 @@
+package org.junit.runner.notification;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.Result;
+
+public class RunNotifierTest {
+    private final RunNotifier fNotifier = new RunNotifier();
+
+    @Test
+    public void notifiesSecondListenerIfFirstThrowsException() {
+        FailureListener failureListener = new FailureListener();
+        fNotifier.addListener(new CorruptListener());
+        fNotifier.addListener(failureListener);
+        fNotifier.fireTestFailure(new Failure(null, null));
+        assertNotNull("The FailureListener registered no failure.",
+                failureListener.failure);
+    }
+
+    @Test
+    public void hasNoProblemsWithFailingListeners() { // see issues 209 and 395
+        fNotifier.addListener(new CorruptListener());
+        fNotifier.addListener(new FailureListener());
+        fNotifier.addListener(new CorruptListener());
+        fNotifier.fireTestRunFinished(new Result());
+    }
+
+    private static class CorruptListener extends RunListener {
+        @Override
+        public void testRunFinished(Result result) throws Exception {
+            throw new RuntimeException();
+        }
+
+        @Override
+        public void testFailure(Failure failure) throws Exception {
+            throw new RuntimeException();
+        }
+    }
+    
+    @Test
+    public void addAndRemoveWithNonThreadSafeListener() {
+        CountingListener listener = new CountingListener();
+        assertThat(listener.fTestStarted.get(), is(0));
+        fNotifier.addListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+        fNotifier.removeListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+    }
+
+    @Test
+    public void addFirstAndRemoveWithNonThreadSafeListener() {
+        CountingListener listener = new CountingListener();
+        assertThat(listener.fTestStarted.get(), is(0));
+        fNotifier.addFirstListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+        fNotifier.removeListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+    }
+    
+    @Test
+    public void addAndRemoveWithThreadSafeListener() {
+        ThreadSafeListener listener = new ThreadSafeListener();
+        assertThat(listener.fTestStarted.get(), is(0));
+        fNotifier.addListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+        fNotifier.removeListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+    }
+
+    @Test
+    public void addFirstAndRemoveWithThreadSafeListener() {
+        ThreadSafeListener listener = new ThreadSafeListener();
+        assertThat(listener.fTestStarted.get(), is(0));
+        fNotifier.addFirstListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+        fNotifier.removeListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+    }
+
+    @Test
+    public void wrapIfNotThreadSafeShouldNotWrapThreadSafeListeners() {
+        ThreadSafeListener listener = new ThreadSafeListener();
+        assertSame(listener, new RunNotifier().wrapIfNotThreadSafe(listener));
+    }
+
+    @Test
+    public void wrapIfNotThreadSafeShouldWrapNonThreadSafeListeners() {
+        CountingListener listener = new CountingListener();
+        RunListener wrappedListener = new RunNotifier().wrapIfNotThreadSafe(listener);
+        assertThat(wrappedListener, instanceOf(SynchronizedRunListener.class));
+    }
+
+    private static class FailureListener extends RunListener {
+        private Failure failure;
+
+        @Override
+        public void testFailure(Failure failure) throws Exception {
+            this.failure = failure;
+        }
+    }
+    
+    private static class CountingListener extends RunListener {
+        final AtomicInteger fTestStarted = new AtomicInteger(0);
+
+        @Override
+        public void testStarted(Description description) throws Exception {
+            fTestStarted.incrementAndGet();
+        }
+    }
+    
+    @RunListener.ThreadSafe
+    private static class ThreadSafeListener extends CountingListener {
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/SynchronizedRunListenerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/SynchronizedRunListenerTest.java
new file mode 100644
index 0000000..6bd39b7
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runner/notification/SynchronizedRunListenerTest.java
@@ -0,0 +1,156 @@
+package org.junit.runner.notification;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Test;
+
+/**
+ * Tests for {@link SynchronizedRunListener}.
+ *
+ * @author kcooney (Kevin Cooney)
+ */
+public class SynchronizedRunListenerTest {
+
+    private static class MethodSignature {
+        private final Method fMethod;
+        private final String fName;
+        private final List<Class<?>> fParameterTypes;
+
+        public MethodSignature(Method method) {
+            fMethod = method;
+            fName = method.getName();
+            fParameterTypes = Arrays.asList(method.getParameterTypes());
+        }
+
+        @Override
+        public String toString() {
+            return fMethod.toString();
+        }
+
+        @Override
+        public int hashCode() {
+            return fName.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof MethodSignature)) {
+                return false;
+            }
+            MethodSignature that = (MethodSignature) obj;
+            return fName.equals(that.fName) && fParameterTypes.equals(that.fParameterTypes);
+        }
+    }
+
+    private Set<MethodSignature> getAllDeclaredMethods(Class<?> type) {
+        Set<MethodSignature> methods = new HashSet<MethodSignature>();
+        for (Method method : type.getDeclaredMethods()) {
+          methods.add(new MethodSignature(method));
+        }
+        return methods;
+    }
+
+    @Test
+    public void overridesAllMethodsInRunListener() {
+        Set<MethodSignature> runListenerMethods = getAllDeclaredMethods(RunListener.class);
+        Set<MethodSignature> synchronizedRunListenerMethods = getAllDeclaredMethods(
+                SynchronizedRunListener.class);
+
+        assertTrue(synchronizedRunListenerMethods.containsAll(runListenerMethods));
+    }
+
+    private static class NamedListener extends RunListener {
+        private final String fName;
+
+        public NamedListener(String name) {
+            fName = name;
+        }
+
+        @Override
+        public String toString() {
+          return "NamedListener";
+        }
+
+        @Override
+        public int hashCode() {
+            return fName.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof NamedListener)) {
+                return false;
+            }
+            NamedListener that = (NamedListener) obj;
+            return this.fName.equals(that.fName);
+        }
+    }
+
+    @Test
+    public void namedListenerCorrectlyImplementsEqualsAndHashCode() {
+        NamedListener listener1 = new NamedListener("blue");
+        NamedListener listener2 = new NamedListener("blue");
+        NamedListener listener3 = new NamedListener("red");
+
+        assertTrue(listener1.equals(listener1));
+        assertTrue(listener2.equals(listener2));
+        assertTrue(listener3.equals(listener3));
+
+        assertFalse(listener1.equals(null));
+        assertFalse(listener1.equals(new Object()));
+
+        assertTrue(listener1.equals(listener2));
+        assertTrue(listener2.equals(listener1));
+        assertFalse(listener1.equals(listener3));
+        assertFalse(listener3.equals(listener1));
+
+        assertEquals(listener1.hashCode(), listener2.hashCode());
+        assertNotEquals(listener1.hashCode(), listener3.hashCode());
+    }
+
+    @Test
+    public void toStringDelegates() {
+        NamedListener listener = new NamedListener("blue");
+
+        assertEquals("NamedListener", listener.toString());
+        assertEquals("NamedListener (with synchronization wrapper)", wrap(listener).toString());
+    }
+
+    @Test
+    public void equalsDelegates() {
+        NamedListener listener1 = new NamedListener("blue");
+        NamedListener listener2 = new NamedListener("blue");
+        NamedListener listener3 = new NamedListener("red");
+
+        assertEquals(wrap(listener1), wrap(listener1));
+        assertEquals(wrap(listener1), wrap(listener2));
+        assertNotEquals(wrap(listener1), wrap(listener3));
+        assertNotEquals(wrap(listener1), listener1);
+        assertNotEquals(listener1, wrap(listener1));
+    }
+
+    @Test
+    public void hashCodeDelegates() {
+        NamedListener listener = new NamedListener("blue");
+        assertEquals(listener.hashCode(), wrap(listener).hashCode());
+    }
+
+    private SynchronizedRunListener wrap(RunListener listener) {
+        return new SynchronizedRunListener(listener, this);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/AllRunnersTests.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/AllRunnersTests.java
new file mode 100644
index 0000000..5464fb2
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/AllRunnersTests.java
@@ -0,0 +1,16 @@
+package org.junit.runners;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite.SuiteClasses;
+import org.junit.runners.model.AllModelTests;
+import org.junit.runners.parameterized.AllParameterizedTests;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AllModelTests.class,
+        AllParameterizedTests.class,
+        RuleContainerTest.class,
+        CustomBlockJUnit4ClassRunnerTest.class
+})
+public class AllRunnersTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/CustomBlockJUnit4ClassRunnerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/CustomBlockJUnit4ClassRunnerTest.java
new file mode 100644
index 0000000..d9f072b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/CustomBlockJUnit4ClassRunnerTest.java
@@ -0,0 +1,90 @@
+package org.junit.runners;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+
+/**
+ * Tests that verify proper behavior for custom runners that extend
+ * {@link BlockJUnit4ClassRunner}.
+ *
+ * @author Sam Brannen
+ * @since 4.13
+ */
+public class CustomBlockJUnit4ClassRunnerTest {
+
+	@Test
+	public void exceptionsFromMethodBlockMustNotResultInUnrootedTests() throws Exception {
+		TrackingRunListener listener = new TrackingRunListener();
+		RunNotifier notifier = new RunNotifier();
+		notifier.addListener(listener);
+
+		new CustomBlockJUnit4ClassRunner(CustomBlockJUnit4ClassRunnerTestCase.class).run(notifier);
+		assertEquals("tests started.", 2, listener.testStartedCount.get());
+		assertEquals("tests failed.", 1, listener.testFailureCount.get());
+		assertEquals("tests finished.", 2, listener.testFinishedCount.get());
+	}
+
+
+	public static class CustomBlockJUnit4ClassRunnerTestCase {
+		@Test public void shouldPass() { /* no-op */ }
+		@Test public void throwException() { /* no-op */ }
+	}
+
+	/**
+	 * Custom extension of {@link BlockJUnit4ClassRunner} that always throws
+	 * an exception from the {@code methodBlock()} if a test method is named
+	 * exactly {@code "throwException"}.
+	 */
+	private static class CustomBlockJUnit4ClassRunner extends BlockJUnit4ClassRunner {
+
+		CustomBlockJUnit4ClassRunner(Class<?> testClass) throws InitializationError {
+			super(testClass);
+		}
+
+		@Override
+		protected Statement methodBlock(FrameworkMethod method) {
+			if ("throwException".equals(method.getName())) {
+				throw new RuntimeException("throwException() test method invoked");
+			}
+			return super.methodBlock(method);
+		}
+	}
+
+	/**
+	 * Simple {@link RunListener} that tracks the number of times that
+	 * certain callbacks are invoked.
+	 */
+	private static class TrackingRunListener extends RunListener {
+
+		final AtomicInteger testStartedCount = new AtomicInteger();
+		final AtomicInteger testFailureCount = new AtomicInteger();
+		final AtomicInteger testFinishedCount = new AtomicInteger();
+
+
+		@Override
+		public void testStarted(Description description) throws Exception {
+			testStartedCount.incrementAndGet();
+		}
+
+		@Override
+		public void testFailure(Failure failure) throws Exception {
+			testFailureCount.incrementAndGet();
+		}
+
+		@Override
+		public void testFinished(Description description) throws Exception {
+			testFinishedCount.incrementAndGet();
+		}
+	}
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/RuleContainerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/RuleContainerTest.java
new file mode 100644
index 0000000..8c6649c
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/RuleContainerTest.java
@@ -0,0 +1,68 @@
+package org.junit.runners;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+public class RuleContainerTest {
+    private final RuleContainer container = new RuleContainer();
+
+    @Test
+    public void methodRulesOnly() {
+        container.add(MRule.M1);
+        container.add(MRule.M2);
+        assertEquals("[M1, M2]", container.getSortedRules().toString());
+        container.setOrder(MRule.M2, 1);
+        assertEquals("[M2, M1]", container.getSortedRules().toString());
+    }
+
+    @Test
+    public void testRuleAroundMethodRule() {
+        container.add(MRule.M1);
+        container.add(Rule.A);
+        assertEquals("[M1, A]", container.getSortedRules().toString());
+    }
+
+    @Test
+    public void ordering1() {
+        container.add(MRule.M1);
+        container.add(Rule.A);
+        container.setOrder(Rule.A, 1);
+        assertEquals("[A, M1]", container.getSortedRules().toString());
+    }
+
+    @Test
+    public void ordering2() {
+        container.add(Rule.A);
+        container.add(Rule.B);
+        container.add(Rule.C);
+        assertEquals("[A, B, C]", container.getSortedRules().toString());
+        container.setOrder(Rule.B, 1);
+        container.setOrder(Rule.C, 2);
+        assertEquals("[C, B, A]", container.getSortedRules().toString());
+    }
+
+    private enum Rule implements TestRule {
+        A,
+        B,
+        C;
+
+        public Statement apply(Statement base, Description description) {
+            return base;
+        }
+    }
+
+    private enum MRule implements MethodRule {
+        M1,
+        M2;
+
+        public Statement apply(Statement base, FrameworkMethod method, Object target) {
+            return base;
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/model/AllModelTests.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/AllModelTests.java
new file mode 100644
index 0000000..b0c50d5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/AllModelTests.java
@@ -0,0 +1,15 @@
+package org.junit.runners.model;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        FrameworkFieldTest.class,
+        FrameworkMethodTest.class,
+        InvalidTestClassErrorTest.class,
+        TestClassTest.class
+})
+public class AllModelTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/model/FrameworkFieldTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/FrameworkFieldTest.java
new file mode 100644
index 0000000..55ba75e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/FrameworkFieldTest.java
@@ -0,0 +1,58 @@
+package org.junit.runners.model;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.rules.ExpectedException.none;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+public class FrameworkFieldTest {
+    @Rule
+    public final ExpectedException thrown = none();
+
+    @Test
+    public void cannotBeCreatedWithoutUnderlyingField() {
+        thrown.expect(NullPointerException.class);
+        thrown.expectMessage("FrameworkField cannot be created without an underlying field.");
+        new FrameworkField(null);
+    }
+
+    @Test
+    public void hasToStringWhichPrintsFieldName() throws Exception {
+        Field field = ClassWithDummyField.class.getField("dummyField");
+        FrameworkField frameworkField = new FrameworkField(field);
+        assertTrue(frameworkField.toString().contains("dummyField"));
+    }
+
+    @Test
+    public void presentAnnotationIsAvailable() throws Exception {
+        Field field = ClassWithDummyField.class.getField("annotatedField");
+        FrameworkField frameworkField = new FrameworkField(field);
+        Annotation annotation = frameworkField.getAnnotation(Rule.class);
+        assertTrue(Rule.class.isAssignableFrom(annotation.getClass()));
+    }
+
+    @Test
+    public void missingAnnotationIsNotAvailable() throws Exception {
+        Field field = ClassWithDummyField.class.getField("annotatedField");
+        FrameworkField frameworkField = new FrameworkField(field);
+        Annotation annotation = frameworkField.getAnnotation(ClassRule.class);
+        assertThat(annotation, is(nullValue()));
+    }
+
+    private static class ClassWithDummyField {
+        @SuppressWarnings("unused")
+        public final int dummyField = 0;
+
+        @Rule
+        public final int annotatedField = 0;
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/model/FrameworkMethodTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/FrameworkMethodTest.java
new file mode 100644
index 0000000..b97df82
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/FrameworkMethodTest.java
@@ -0,0 +1,60 @@
+package org.junit.runners.model;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.rules.ExpectedException.none;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+public class FrameworkMethodTest {
+    @Rule
+    public final ExpectedException thrown = none();
+
+    @Test
+    public void cannotBeCreatedWithoutUnderlyingField() {
+        thrown.expect(NullPointerException.class);
+        thrown.expectMessage("FrameworkMethod cannot be created without an underlying method.");
+        new FrameworkMethod(null);
+    }
+
+    @Test
+    public void hasToStringWhichPrintsMethodName() throws Exception {
+        Method method = ClassWithDummyMethod.class.getMethod("dummyMethod");
+        FrameworkMethod frameworkMethod = new FrameworkMethod(method);
+        assertTrue(frameworkMethod.toString().contains("dummyMethod"));
+    }
+
+    @Test
+    public void presentAnnotationIsAvailable() throws Exception {
+        Method method = ClassWithDummyMethod.class.getMethod("annotatedDummyMethod");
+        FrameworkMethod frameworkMethod = new FrameworkMethod(method);
+        Annotation annotation = frameworkMethod.getAnnotation(Rule.class);
+        assertTrue(Rule.class.isAssignableFrom(annotation.getClass()));
+    }
+
+    @Test
+    public void missingAnnotationIsNotAvailable() throws Exception {
+        Method method = ClassWithDummyMethod.class.getMethod("annotatedDummyMethod");
+        FrameworkMethod frameworkMethod = new FrameworkMethod(method);
+        Annotation annotation = frameworkMethod.getAnnotation(ClassRule.class);
+        assertThat(annotation, is(nullValue()));
+    }
+
+    private static class ClassWithDummyMethod {
+        @SuppressWarnings("unused")
+        public void dummyMethod() {
+        }
+
+        @Rule
+        public void annotatedDummyMethod() {
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/model/InvalidTestClassErrorTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/InvalidTestClassErrorTest.java
new file mode 100644
index 0000000..7d92dd4
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/InvalidTestClassErrorTest.java
@@ -0,0 +1,23 @@
+package org.junit.runners.model;
+
+import org.junit.Test;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class InvalidTestClassErrorTest {
+
+    @Test
+    public void invalidTestClassErrorShouldListAllValidationErrorsInItsMessage() {
+        InvalidTestClassError sut = new InvalidTestClassError(SampleTestClass.class,
+                asList(new Throwable("validation error 1"), new Throwable("validation error 2")));
+
+        assertThat(sut.getMessage(), equalTo("Invalid test class '" + SampleTestClass.class.getName() + "':" +
+                "\n  1. validation error 1" +
+                "\n  2. validation error 2"));
+    }
+
+    private static class SampleTestClass {
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/model/RunnerBuilderStub.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/RunnerBuilderStub.java
new file mode 100644
index 0000000..2e11137
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/RunnerBuilderStub.java
@@ -0,0 +1,11 @@
+package org.junit.runners.model;
+
+import org.junit.runner.Runner;
+import org.junit.runner.RunnerSpy;
+
+public class RunnerBuilderStub extends RunnerBuilder {
+    @Override
+    public Runner runnerForClass(Class<?> testClass) throws Throwable {
+        return new RunnerSpy(testClass, this);
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/model/TestClassTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/TestClassTest.java
new file mode 100644
index 0000000..6b5cb28
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/model/TestClassTest.java
@@ -0,0 +1,263 @@
+package org.junit.runners.model;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.rules.TestRule;
+import org.junit.runner.RunWith;
+
+public class TestClassTest {
+
+    @Rule
+    public ExpectedException exception = ExpectedException.none();
+
+    public static class TwoConstructors {
+        public TwoConstructors() {
+        }
+
+        public TwoConstructors(int x) {
+        }
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void complainIfMultipleConstructors() {
+        new TestClass(TwoConstructors.class);
+    }
+
+    public static class SuperclassWithField {
+        @Rule
+        public TestRule x;
+    }
+
+    public static class SubclassWithField extends SuperclassWithField {
+        @Rule
+        public TestRule x;
+    }
+
+    @Test
+    public void fieldsOnSubclassesShadowSuperclasses() {
+        assertThat(new TestClass(SubclassWithField.class).getAnnotatedFields(
+                Rule.class).size(), is(1));
+    }
+
+    public static class OuterClass {
+        public class NonStaticInnerClass {
+        }
+    }
+
+    @Test
+    public void identifyNonStaticInnerClass() {
+        assertThat(
+                new TestClass(OuterClass.NonStaticInnerClass.class)
+                        .isANonStaticInnerClass(),
+                is(true));
+    }
+
+    public static class OuterClass2 {
+        public static class StaticInnerClass {
+        }
+    }
+
+    @Test
+    public void dontMarkStaticInnerClassAsNonStatic() {
+        assertThat(
+                new TestClass(OuterClass2.StaticInnerClass.class)
+                        .isANonStaticInnerClass(),
+                is(false));
+    }
+
+    public static class SimpleClass {
+    }
+
+    @Test
+    public void dontMarkNonInnerClassAsInnerClass() {
+        assertThat(new TestClass(SimpleClass.class).isANonStaticInnerClass(),
+                is(false));
+    }
+
+    public static class FieldAnnotated {
+        @Rule
+        public String fieldC= "andromeda";
+
+        @Rule
+        public boolean fieldA;
+
+        @Rule
+        public boolean fieldB;
+    }
+
+    @Test
+    public void providesAnnotatedFieldsSortedByName() {
+        TestClass tc= new TestClass(FieldAnnotated.class);
+        List<FrameworkField> annotatedFields= tc.getAnnotatedFields();
+        assertThat("Wrong number of annotated fields.", annotatedFields.size(), is(3));
+        assertThat("First annotated field is wrong.", annotatedFields
+            .iterator().next().getName(), is("fieldA"));
+    }
+
+    @Test
+    public void annotatedFieldValues() {
+        TestClass tc = new TestClass(FieldAnnotated.class);
+        List<String> values = tc.getAnnotatedFieldValues(new FieldAnnotated(), Rule.class, String.class);
+        assertThat(values, hasItem("andromeda"));
+        assertThat(values.size(), is(1));
+    }
+
+    public static class MethodsAnnotated {
+        @Ignore
+        @Test
+        public int methodC() {
+            return 0;
+        }
+
+        @Ignore
+        @Test
+        public String methodA() {
+            return "jupiter";
+        }
+
+        @Ignore
+        @Test
+        public int methodB() {
+            return 0;
+        }
+
+        public int methodWithoutAnnotation() {
+            return 0;
+        }
+    }
+
+    @Test
+    public void providesAnnotatedMethodsSortedByName() {
+        TestClass tc = new TestClass(MethodsAnnotated.class);
+        List<FrameworkMethod> annotatedMethods = tc.getAnnotatedMethods();
+        List<String> methodNames = extractNames(annotatedMethods);
+        assertThat(methodNames.indexOf("methodA"),
+            lessThan(methodNames.indexOf("methodB")));
+    }
+
+    @Test
+    public void getAnnotatedMethodsDoesNotReturnMethodWithoutAnnotation() {
+        TestClass tc = new TestClass(MethodsAnnotated.class);
+        List<FrameworkMethod> annotatedMethods = tc.getAnnotatedMethods();
+        List<String> methodNames = extractNames(annotatedMethods);
+        assertThat(methodNames, not(hasItem("methodWithoutAnnotation")));
+    }
+
+    private List<String> extractNames(List<FrameworkMethod> methods) {
+        List<String> names = new ArrayList<String>();
+        for (FrameworkMethod method: methods) {
+            names.add(method.getName());
+        }
+        return names;
+    }
+
+    @Test
+    public void annotatedMethodValues() {
+        TestClass tc = new TestClass(MethodsAnnotated.class);
+        List<String> values = tc.getAnnotatedMethodValues(
+            new MethodsAnnotated(), Ignore.class, String.class);
+        assertThat(values, hasItem("jupiter"));
+        assertThat(values.size(), is(1));
+    }
+
+    @Test
+    public void isEqualToTestClassThatWrapsSameJavaClass() {
+        TestClass testClass = new TestClass(DummyClass.class);
+        TestClass testClassThatWrapsSameJavaClass = new TestClass(
+                DummyClass.class);
+        assertTrue(testClass.equals(testClassThatWrapsSameJavaClass));
+    }
+
+    @Test
+    public void isEqualToTestClassThatWrapsNoJavaClassToo() {
+        TestClass testClass = new TestClass(null);
+        TestClass testClassThatWrapsNoJavaClassToo = new TestClass(null);
+        assertTrue(testClass.equals(testClassThatWrapsNoJavaClassToo));
+    }
+
+    @Test
+    public void isNotEqualToTestClassThatWrapsADifferentJavaClass() {
+        TestClass testClass = new TestClass(DummyClass.class);
+        TestClass testClassThatWrapsADifferentJavaClass = new TestClass(
+                AnotherDummyClass.class);
+        assertFalse(testClass.equals(testClassThatWrapsADifferentJavaClass));
+    }
+
+    @Test
+    public void isNotEqualToNull() {
+        TestClass testClass = new TestClass(DummyClass.class);
+        assertFalse(testClass.equals(null));
+    }
+
+    private static class DummyClass {
+    }
+
+    private static class AnotherDummyClass {
+    }
+
+    @Test
+    public void hasSameHashCodeAsTestClassThatWrapsSameJavaClass() {
+        TestClass testClass = new TestClass(DummyClass.class);
+        TestClass testClassThatWrapsSameJavaClass = new TestClass(
+                DummyClass.class);
+        assertEquals(testClass.hashCode(),
+                testClassThatWrapsSameJavaClass.hashCode());
+    }
+
+    @Test
+    public void hasHashCodeWithoutJavaClass() {
+        TestClass testClass = new TestClass(null);
+        testClass.hashCode();
+        // everything is fine if no exception is thrown.
+    }
+
+    public static class PublicClass {
+
+    }
+
+    @Test
+    public void identifiesPublicModifier() {
+        TestClass tc = new TestClass(PublicClass.class);
+        assertEquals("Wrong flag 'public',", true, tc.isPublic());
+    }
+
+    static class NonPublicClass {
+
+    }
+    
+    @Test
+    public void identifiesNonPublicModifier() {
+        TestClass tc = new TestClass(NonPublicClass.class);
+        assertEquals("Wrong flag 'public',", false, tc.isPublic());
+    }
+
+    @Ignore
+    static class AnnotatedClass {
+    }
+
+    @Test
+    public void presentAnnotationIsAvailable() {
+        TestClass tc = new TestClass(AnnotatedClass.class);
+        Annotation annotation = tc.getAnnotation(Ignore.class);
+        assertTrue(Ignore.class.isAssignableFrom(annotation.getClass()));
+    }
+
+    @Test
+    public void missingAnnotationIsNotAvailable() {
+        TestClass tc = new TestClass(AnnotatedClass.class);
+        Annotation annotation = tc.getAnnotation(RunWith.class);
+        assertThat(annotation, is(nullValue()));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/AllParameterizedTests.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/AllParameterizedTests.java
new file mode 100644
index 0000000..9a0f261
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/AllParameterizedTests.java
@@ -0,0 +1,14 @@
+package org.junit.runners.parameterized;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        BlockJUnit4ClassRunnerWithParametersTest.class,
+        ParameterizedNamesTest.class,
+        TestWithParametersTest.class
+})
+public class AllParameterizedTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParametersTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParametersTest.java
new file mode 100644
index 0000000..0896c1f
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParametersTest.java
@@ -0,0 +1,80 @@
+package org.junit.runners.parameterized;
+
+import static java.util.Collections.emptyList;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.junit.Assert.assertEquals;
+import static org.junit.rules.ExpectedException.none;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.model.TestClass;
+
+public class BlockJUnit4ClassRunnerWithParametersTest {
+    private static final List<Object> NO_PARAMETERS = emptyList();
+
+    @Rule
+    public final ExpectedException thrown = none();
+
+    @RunWith(Parameterized.class)
+    @DummyAnnotation
+    public static class ClassWithParameterizedAnnotation {
+        @Test
+        public void dummyTest() {
+        }
+    }
+
+    @Test
+    public void hasAllAnnotationsExceptRunWith() throws Exception {
+        TestWithParameters testWithParameters = new TestWithParameters(
+                "dummy name", new TestClass(
+                        ClassWithParameterizedAnnotation.class), NO_PARAMETERS);
+        BlockJUnit4ClassRunnerWithParameters runner = new BlockJUnit4ClassRunnerWithParameters(
+                testWithParameters);
+        Annotation[] annotations = runner.getRunnerAnnotations();
+        assertEquals(1, annotations.length);
+        assertEquals(annotations[0].annotationType(), DummyAnnotation.class);
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.TYPE)
+    private static @interface DummyAnnotation {
+    }
+
+    @RunWith(Parameterized.class)
+    public static class ClassWithPrivateParameter {
+        @Parameterized.Parameter
+        private String parameter;
+
+        @Test
+        public void dummyTest() {
+        }
+    }
+
+    @Test
+    public void providesHelpfulMessageIfParameterFieldCannotBeSet()
+            throws Exception {
+        TestWithParameters testWithParameters = new TestWithParameters(
+                "dummy name",
+                new TestClass(ClassWithPrivateParameter.class),
+                Collections.<Object>singletonList("dummy parameter"));
+        BlockJUnit4ClassRunnerWithParameters runner = new BlockJUnit4ClassRunnerWithParameters(
+                testWithParameters);
+
+        thrown.expect(IllegalAccessException.class);
+        thrown.expectCause(instanceOf(IllegalAccessException.class));
+        thrown.expectMessage("Cannot set parameter 'parameter'. Ensure that the field 'parameter' is public.");
+
+        runner.createTest();
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/ParameterizedNamesTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/ParameterizedNamesTest.java
new file mode 100644
index 0000000..e04fb76
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/ParameterizedNamesTest.java
@@ -0,0 +1,51 @@
+package org.junit.runners.parameterized;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.Request;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Dmitry Baev charlie@yandex-team.ru
+ *         Date: 03.05.14
+ */
+public class ParameterizedNamesTest {
+    @RunWith(Parameterized.class)
+    public static class ParameterizedWithSpecialCharsInName {
+
+        public ParameterizedWithSpecialCharsInName(String s) {
+        }
+
+        @Parameterized.Parameters(name = "{0}")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(
+                    new Object[]{"\n"},
+                    new Object[]{"\r\n"},
+                    new Object[]{"\r"},
+                    new Object[]{"\u0085"},
+                    new Object[]{"\u2028"},
+                    new Object[]{"\u2029"}
+            );
+        }
+
+        @Test
+        public void test() {
+        }
+    }
+
+    @Test
+    public void parameterizedTestsWithSpecialCharsInName() {
+        Request request = Request.aClass(ParameterizedWithSpecialCharsInName.class);
+        for (Description parent : request.getRunner().getDescription().getChildren()) {
+            for (Description description : parent.getChildren()) {
+                assertEquals("test" + parent.getDisplayName(), description.getMethodName());
+            }
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/TestWithParametersTest.java b/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/TestWithParametersTest.java
new file mode 100644
index 0000000..b8156e9
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/runners/parameterized/TestWithParametersTest.java
@@ -0,0 +1,137 @@
+package org.junit.runners.parameterized;
+
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.rules.ExpectedException.none;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runners.model.TestClass;
+
+public class TestWithParametersTest {
+    private static final String DUMMY_NAME = "dummy name";
+
+    private static final TestClass DUMMY_TEST_CLASS = new TestClass(
+            DummyClass.class);
+
+    private static final List<Object> DUMMY_PARAMETERS = Arrays
+            .<Object> asList("a", "b");
+
+    @Rule
+    public final ExpectedException thrown = none();
+
+    @Test
+    public void cannotBeCreatedWithoutAName() {
+        thrown.expect(NullPointerException.class);
+        thrown.expectMessage("The name is missing.");
+        new TestWithParameters(null, DUMMY_TEST_CLASS, DUMMY_PARAMETERS);
+    }
+
+    @Test
+    public void cannotBeCreatedWithoutTestClass() {
+        thrown.expect(NullPointerException.class);
+        thrown.expectMessage("The test class is missing.");
+        new TestWithParameters(DUMMY_NAME, null, DUMMY_PARAMETERS);
+    }
+
+    @Test
+    public void cannotBeCreatedWithoutParameters() {
+        thrown.expect(NullPointerException.class);
+        thrown.expectMessage("The parameters are missing.");
+        new TestWithParameters(DUMMY_NAME, DUMMY_TEST_CLASS,
+                (List<Object>) null);
+    }
+
+    @Test
+    public void doesNotAllowToModifyProvidedParameters() {
+        TestWithParameters test = new TestWithParameters(DUMMY_NAME,
+                DUMMY_TEST_CLASS, DUMMY_PARAMETERS);
+        thrown.expect(UnsupportedOperationException.class);
+        test.getParameters().set(0, "another parameter");
+    }
+
+    @Test
+    public void doesNotConsiderParametersWhichChangedAfterTestInstantiation() {
+        List<Object> parameters = Arrays.<Object> asList("dummy parameter");
+        TestWithParameters test = new TestWithParameters(DUMMY_NAME,
+                DUMMY_TEST_CLASS, parameters);
+        parameters.set(0, "another parameter");
+        assertEquals(asList("dummy parameter"), test.getParameters());
+    }
+
+    @Test
+    public void isEqualToTestWithSameNameAndTestClassAndParameters() {
+        TestWithParameters firstTest = new TestWithParameters(DUMMY_NAME,
+                new TestClass(DummyClass.class), Arrays.<Object> asList("a",
+                        "b"));
+        TestWithParameters secondTest = new TestWithParameters(DUMMY_NAME,
+                new TestClass(DummyClass.class), Arrays.<Object> asList("a",
+                        "b"));
+        assertEquals(firstTest, secondTest);
+    }
+
+    @Test
+    public void isNotEqualToTestWithDifferentName() {
+        TestWithParameters firstTest = new TestWithParameters("name",
+                DUMMY_TEST_CLASS, DUMMY_PARAMETERS);
+        TestWithParameters secondTest = new TestWithParameters("another name",
+                DUMMY_TEST_CLASS, DUMMY_PARAMETERS);
+        assertNotEquals(firstTest, secondTest);
+    }
+
+    @Test
+    public void isNotEqualToTestWithDifferentTestClass() {
+        TestWithParameters firstTest = new TestWithParameters(DUMMY_NAME,
+                new TestClass(DummyClass.class), DUMMY_PARAMETERS);
+        TestWithParameters secondTest = new TestWithParameters(DUMMY_NAME,
+                new TestClass(AnotherDummyClass.class), DUMMY_PARAMETERS);
+        assertNotEquals(firstTest, secondTest);
+    }
+
+    @Test
+    public void isNotEqualToTestWithDifferentParameters() {
+        TestWithParameters firstTest = new TestWithParameters(DUMMY_NAME,
+                DUMMY_TEST_CLASS, Arrays.<Object> asList("a"));
+        TestWithParameters secondTest = new TestWithParameters(DUMMY_NAME,
+                DUMMY_TEST_CLASS, Arrays.<Object> asList("b"));
+        assertNotEquals(firstTest, secondTest);
+    }
+
+    @Test
+    public void isNotEqualToObjectWithDifferentClass() {
+        TestWithParameters test = new TestWithParameters(DUMMY_NAME,
+                DUMMY_TEST_CLASS, DUMMY_PARAMETERS);
+        assertNotEquals(test, new Integer(3));
+    }
+
+    @Test
+    public void hasSameHashCodeAsEqualTest() {
+        TestWithParameters firstTest = new TestWithParameters(DUMMY_NAME,
+                DUMMY_TEST_CLASS, DUMMY_PARAMETERS);
+        TestWithParameters secondTest = new TestWithParameters(DUMMY_NAME,
+                DUMMY_TEST_CLASS, DUMMY_PARAMETERS);
+        assertEquals(firstTest.hashCode(), secondTest.hashCode());
+    }
+
+    @Test
+    public void hasMeaningfulToString() {
+        TestWithParameters test = new TestWithParameters("name", new TestClass(
+                DummyClass.class), Arrays.<Object> asList("first parameter",
+                "second parameter"));
+        assertEquals(
+                "Wrong toString().",
+                "org.junit.runners.parameterized.TestWithParametersTest$DummyClass 'name' with parameters [first parameter, second parameter]",
+                test.toString());
+    }
+
+    private static class DummyClass {
+    }
+
+    private static class AnotherDummyClass {
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/samples/AllSamplesTests.java b/google3/third_party/java_src/junit/test/java/org/junit/samples/AllSamplesTests.java
new file mode 100644
index 0000000..cbd5fce
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/samples/AllSamplesTests.java
@@ -0,0 +1,14 @@
+package org.junit.samples;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+import org.junit.samples.money.MoneyTest;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        ListTest.class,
+        MoneyTest.class
+})
+public class AllSamplesTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/samples/ListTest.java b/google3/third_party/java_src/junit/test/java/org/junit/samples/ListTest.java
new file mode 100644
index 0000000..02ade82
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/samples/ListTest.java
@@ -0,0 +1,91 @@
+package org.junit.samples;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import junit.framework.JUnit4TestAdapter;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+/**
+ * A sample test case, testing {@link java.util.ArrayList}.
+ */
+public class ListTest {
+    protected List<Integer> fEmpty;
+    protected List<Integer> fFull;
+    protected static List<Integer> fgHeavy;
+
+    public static void main(String... args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+    @BeforeClass
+    public static void setUpOnce() {
+        fgHeavy = new ArrayList<Integer>();
+        for (int i = 0; i < 1000; i++) {
+            fgHeavy.add(i);
+        }
+    }
+
+    @Before
+    public void setUp() {
+        fEmpty = new ArrayList<Integer>();
+        fFull = new ArrayList<Integer>();
+        fFull.add(1);
+        fFull.add(2);
+        fFull.add(3);
+    }
+
+    public static junit.framework.Test suite() {
+        return new JUnit4TestAdapter(ListTest.class);
+    }
+
+    @Ignore("not today")
+    @Test
+    public void capacity() {
+        int size = fFull.size();
+        for (int i = 0; i < 100; i++) {
+            fFull.add(i);
+        }
+        assertTrue(fFull.size() == 100 + size);
+    }
+
+    @Test
+    public void testCopy() {
+        List<Integer> copy = new ArrayList<Integer>(fFull.size());
+        copy.addAll(fFull);
+        assertTrue(copy.size() == fFull.size());
+        assertTrue(copy.contains(1));
+    }
+
+    @Test
+    public void contains() {
+        assertTrue(fFull.contains(1));
+        assertTrue(!fEmpty.contains(1));
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void elementAt() {
+        int i = fFull.get(0);
+        assertTrue(i == 1);
+        fFull.get(fFull.size()); // Should throw IndexOutOfBoundsException
+    }
+
+    @Test
+    public void removeAll() {
+        fFull.removeAll(fFull);
+        fEmpty.removeAll(fEmpty);
+        assertTrue(fFull.isEmpty());
+        assertTrue(fEmpty.isEmpty());
+    }
+
+    @Test
+    public void removeElement() {
+        fFull.remove(new Integer(3));
+        assertTrue(!fFull.contains(3));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/samples/SimpleTest.java b/google3/third_party/java_src/junit/test/java/org/junit/samples/SimpleTest.java
new file mode 100644
index 0000000..02bae09
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/samples/SimpleTest.java
@@ -0,0 +1,47 @@
+package org.junit.samples;
+
+import static org.junit.Assert.assertEquals;
+
+import junit.framework.JUnit4TestAdapter;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Some simple tests.
+ *
+ * <p>This test is expected to fail.
+ */
+public class SimpleTest {
+    protected int fValue1;
+    protected int fValue2;
+
+    @Before
+    public void setUp() {
+        fValue1 = 2;
+        fValue2 = 3;
+    }
+
+    public static junit.framework.Test suite() {
+        return new JUnit4TestAdapter(SimpleTest.class);
+    }
+
+    public int unused;
+
+    @Test
+    public void divideByZero() {
+        int zero = 0;
+        int result = 8 / zero;
+        unused = result; // avoid warning for not using result
+    }
+
+    @Test
+    public void testEquals() {
+        assertEquals(12, 12);
+        assertEquals(12L, 12L);
+        assertEquals(new Long(12), new Long(12));
+
+        assertEquals("Size", 12, 13);
+        assertEquals("Capacity", 12.0, 11.99, 0.0);
+    }
+
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/samples/money/MoneyTest.java b/google3/third_party/java_src/junit/test/java/org/junit/samples/money/MoneyTest.java
new file mode 100644
index 0000000..617bcec
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/samples/money/MoneyTest.java
@@ -0,0 +1,205 @@
+package org.junit.samples.money;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import junit.framework.JUnit4TestAdapter;
+import junit.samples.money.IMoney;
+import junit.samples.money.Money;
+import junit.samples.money.MoneyBag;
+import org.junit.Before;
+import org.junit.Test;
+
+public class MoneyTest {
+    private Money f12CHF;
+    private Money f14CHF;
+    private Money f7USD;
+    private Money f21USD;
+
+    private IMoney fMB1;
+    private IMoney fMB2;
+
+    public static junit.framework.Test suite() {
+        return new JUnit4TestAdapter(MoneyTest.class);
+    }
+
+    @Before
+    public void setUp() {
+        f12CHF = new Money(12, "CHF");
+        f14CHF = new Money(14, "CHF");
+        f7USD = new Money(7, "USD");
+        f21USD = new Money(21, "USD");
+
+        fMB1 = MoneyBag.create(f12CHF, f7USD);
+        fMB2 = MoneyBag.create(f14CHF, f21USD);
+    }
+
+    @Test
+    public void testBagMultiply() {
+        // {[12 CHF][7 USD]} *2 == {[24 CHF][14 USD]}
+        IMoney expected = MoneyBag.create(new Money(24, "CHF"), new Money(14, "USD"));
+        assertEquals(expected, fMB1.multiply(2));
+        assertEquals(fMB1, fMB1.multiply(1));
+        assertTrue(fMB1.multiply(0).isZero());
+    }
+
+    @Test
+    public void testBagNegate() {
+        // {[12 CHF][7 USD]} negate == {[-12 CHF][-7 USD]}
+        IMoney expected = MoneyBag.create(new Money(-12, "CHF"), new Money(-7, "USD"));
+        assertEquals(expected, fMB1.negate());
+    }
+
+    @Test
+    public void testBagSimpleAdd() {
+        // {[12 CHF][7 USD]} + [14 CHF] == {[26 CHF][7 USD]}
+        IMoney expected = MoneyBag.create(new Money(26, "CHF"), new Money(7, "USD"));
+        assertEquals(expected, fMB1.add(f14CHF));
+    }
+
+    @Test
+    public void testBagSubtract() {
+        // {[12 CHF][7 USD]} - {[14 CHF][21 USD] == {[-2 CHF][-14 USD]}
+        IMoney expected = MoneyBag.create(new Money(-2, "CHF"), new Money(-14, "USD"));
+        assertEquals(expected, fMB1.subtract(fMB2));
+    }
+
+    @Test
+    public void testBagSumAdd() {
+        // {[12 CHF][7 USD]} + {[14 CHF][21 USD]} == {[26 CHF][28 USD]}
+        IMoney expected = MoneyBag.create(new Money(26, "CHF"), new Money(28, "USD"));
+        assertEquals(expected, fMB1.add(fMB2));
+    }
+
+    @Test
+    public void testIsZero() {
+        assertTrue(fMB1.subtract(fMB1).isZero());
+        assertTrue(MoneyBag.create(new Money(0, "CHF"), new Money(0, "USD")).isZero());
+    }
+
+    @Test
+    public void testMixedSimpleAdd() {
+        // [12 CHF] + [7 USD] == {[12 CHF][7 USD]}
+        IMoney expected = MoneyBag.create(f12CHF, f7USD);
+        assertEquals(expected, f12CHF.add(f7USD));
+    }
+
+    @Test
+    public void testBagNotEquals() {
+        IMoney bag = MoneyBag.create(f12CHF, f7USD);
+        assertFalse(bag.equals(new Money(12, "DEM").add(f7USD)));
+    }
+
+    @Test
+    public void testMoneyBagEquals() {
+        assertTrue(!fMB1.equals(null));
+
+        assertEquals(fMB1, fMB1);
+        IMoney equal = MoneyBag.create(new Money(12, "CHF"), new Money(7, "USD"));
+        assertTrue(fMB1.equals(equal));
+        assertTrue(!fMB1.equals(f12CHF));
+        assertTrue(!f12CHF.equals(fMB1));
+        assertTrue(!fMB1.equals(fMB2));
+    }
+
+    @Test
+    public void testMoneyBagHash() {
+        IMoney equal = MoneyBag.create(new Money(12, "CHF"), new Money(7, "USD"));
+        assertEquals(fMB1.hashCode(), equal.hashCode());
+    }
+
+    @Test
+    public void testMoneyEquals() {
+        assertTrue(!f12CHF.equals(null));
+        Money equalMoney = new Money(12, "CHF");
+        assertEquals(f12CHF, f12CHF);
+        assertEquals(f12CHF, equalMoney);
+        assertEquals(f12CHF.hashCode(), equalMoney.hashCode());
+        assertTrue(!f12CHF.equals(f14CHF));
+    }
+
+    @Test
+    public void zeroMoniesAreEqualRegardlessOfCurrency() {
+        Money zeroDollars = new Money(0, "USD");
+        Money zeroFrancs = new Money(0, "CHF");
+
+        assertEquals(zeroDollars, zeroFrancs);
+        assertEquals(zeroDollars.hashCode(), zeroFrancs.hashCode());
+    }
+
+    @Test
+    public void testMoneyHash() {
+        assertTrue(!f12CHF.equals(null));
+        Money equal = new Money(12, "CHF");
+        assertEquals(f12CHF.hashCode(), equal.hashCode());
+    }
+
+    @Test
+    public void testSimplify() {
+        IMoney money = MoneyBag.create(new Money(26, "CHF"), new Money(28, "CHF"));
+        assertEquals(new Money(54, "CHF"), money);
+    }
+
+    @Test
+    public void testNormalize2() {
+        // {[12 CHF][7 USD]} - [12 CHF] == [7 USD]
+        Money expected = new Money(7, "USD");
+        assertEquals(expected, fMB1.subtract(f12CHF));
+    }
+
+    @Test
+    public void testNormalize3() {
+        // {[12 CHF][7 USD]} - {[12 CHF][3 USD]} == [4 USD]
+        IMoney ms1 = MoneyBag.create(new Money(12, "CHF"), new Money(3, "USD"));
+        Money expected = new Money(4, "USD");
+        assertEquals(expected, fMB1.subtract(ms1));
+    }
+
+    @Test
+    public void testNormalize4() { // [12 CHF] - {[12 CHF][3 USD]} == [-3 USD]
+        IMoney ms1 = MoneyBag.create(new Money(12, "CHF"), new Money(3, "USD"));
+        Money expected = new Money(-3, "USD");
+        assertEquals(expected, f12CHF.subtract(ms1));
+    }
+
+    @Test
+    public void testPrint() {
+        assertEquals("[12 CHF]", f12CHF.toString());
+    }
+
+    @Test
+    public void testSimpleAdd() {
+        // [12 CHF] + [14 CHF] == [26 CHF]
+        Money expected = new Money(26, "CHF");
+        assertEquals(expected, f12CHF.add(f14CHF));
+    }
+
+    @Test
+    public void testSimpleBagAdd() {
+        // [14 CHF] + {[12 CHF][7 USD]} == {[26 CHF][7 USD]}
+        IMoney expected = MoneyBag.create(new Money(26, "CHF"), new Money(7, "USD"));
+        assertEquals(expected, f14CHF.add(fMB1));
+    }
+
+    @Test
+    public void testSimpleMultiply() {
+        // [14 CHF] *2 == [28 CHF]
+        Money expected = new Money(28, "CHF");
+        assertEquals(expected, f14CHF.multiply(2));
+    }
+
+    @Test
+    public void testSimpleNegate() {
+        // [14 CHF] negate == [-14 CHF]
+        Money expected = new Money(-14, "CHF");
+        assertEquals(expected, f14CHF.negate());
+    }
+
+    @Test
+    public void testSimpleSubtract() {
+        // [14 CHF] - [12 CHF] == [2 CHF]
+        Money expected = new Money(2, "CHF");
+        assertEquals(expected, f14CHF.subtract(f12CHF));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/samples/money/package-info.java b/google3/third_party/java_src/junit/test/java/org/junit/samples/money/package-info.java
new file mode 100644
index 0000000..2429514
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/samples/money/package-info.java
@@ -0,0 +1,7 @@
+/**
+ * JUnit v4.x Test for the Money example.
+ *
+ * @since 4.0
+ * @see junit.samples.money.Money
+ */
+package org.junit.samples.money;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/samples/package-info.java b/google3/third_party/java_src/junit/test/java/org/junit/samples/package-info.java
new file mode 100644
index 0000000..ec52263
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/samples/package-info.java
@@ -0,0 +1,6 @@
+/**
+ * Provides examples on how to use JUnit 4.
+ *
+ * @since 4.0
+ */
+package org.junit.samples;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/AllTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/AllTests.java
new file mode 100644
index 0000000..fd91691
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/AllTests.java
@@ -0,0 +1,49 @@
+package org.junit.tests;
+
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.Test;
+import org.junit.AssumptionViolatedExceptionTest;
+import org.junit.internal.AllInternalTests;
+import org.junit.rules.AllRulesTests;
+import org.junit.runner.AllRunnerTests;
+import org.junit.runner.RunWith;
+import org.junit.runners.AllRunnersTests;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+import org.junit.samples.AllSamplesTests;
+import org.junit.tests.assertion.AllAssertionTests;
+import org.junit.tests.deprecated.AllDeprecatedTests;
+import org.junit.tests.description.AllDescriptionTests;
+import org.junit.tests.experimental.AllExperimentalTests;
+import org.junit.tests.junit3compatibility.AllJUnit3CompatibilityTests;
+import org.junit.tests.listening.AllListeningTests;
+import org.junit.tests.manipulation.AllManipulationTests;
+import org.junit.tests.running.AllRunningTests;
+import org.junit.tests.validation.AllValidationTests;
+import org.junit.validator.AllValidatorTests;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AllAssertionTests.class,
+        AllDeprecatedTests.class,
+        AllDescriptionTests.class,
+        AllExperimentalTests.class,
+        AllInternalTests.class,
+        AllJUnit3CompatibilityTests.class,
+        AllListeningTests.class,
+        AllManipulationTests.class,
+        AllRulesTests.class,
+        AllRunnersTests.class,
+        AllRunnerTests.class,
+        AllRunningTests.class,
+        AllSamplesTests.class,
+        AllValidationTests.class,
+        AllValidatorTests.class,
+        AssumptionViolatedExceptionTest.class,
+        ObjectContractTest.class
+})
+public class AllTests {
+    public static Test suite() {
+        return new JUnit4TestAdapter(AllTests.class);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/ObjectContractTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/ObjectContractTest.java
new file mode 100644
index 0000000..541a25b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/ObjectContractTest.java
@@ -0,0 +1,46 @@
+package org.junit.tests;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeNotNull;
+import static org.junit.Assume.assumeThat;
+
+import java.lang.reflect.Method;
+
+import org.junit.Test;
+import org.junit.Test.None;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+import org.junit.runners.model.FrameworkMethod;
+
+@RunWith(Theories.class)
+public class ObjectContractTest {
+    @DataPoints
+    public static Object[] objects = {new FrameworkMethod(toStringMethod()),
+            new FrameworkMethod(toStringMethod()), 3, null};
+
+    @Theory
+    @Test(expected = None.class)
+    public void equalsThrowsNoException(Object a, Object b) {
+        assumeNotNull(a);
+        a.equals(b);
+    }
+
+    @Theory
+    public void equalsMeansEqualHashCodes(Object a, Object b) {
+        assumeNotNull(a, b);
+        assumeThat(a, is(b));
+        assertThat(a.hashCode(), is(b.hashCode()));
+    }
+
+    private static Method toStringMethod() {
+        try {
+            return Object.class.getMethod("toString");
+        } catch (SecurityException e) {
+        } catch (NoSuchMethodException e) {
+        }
+        return null;
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/SampleJUnit4Tests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/SampleJUnit4Tests.java
new file mode 100644
index 0000000..739f17b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/SampleJUnit4Tests.java
@@ -0,0 +1,136 @@
+package org.junit.tests;
+
+import org.junit.Before;
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.MethodRule;
+import org.junit.rules.TestRule;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+import java.lang.reflect.Method;
+
+/**
+ * Container for sample JUnit4-style tests used in integration tests.
+ */
+public class SampleJUnit4Tests {
+
+    public static class TestWithOneThrowingTestMethod {
+        
+        @Test
+        public void alwaysThrows() {
+            new FakeClassUnderTest().throwsExceptionWithoutCause();
+        }
+    }
+
+    public static class TestWithOneThrowingTestMethodWithCause {
+        
+        @Test
+        public void alwaysThrows() {
+            new FakeClassUnderTest().throwsExceptionWithCause();
+        }
+    }
+
+    public static class TestWithThrowingBeforeMethod {
+
+        @Before
+        public void alwaysThrows() {
+            new FakeClassUnderTest().throwsExceptionWithoutCause();
+        }
+
+        @Test
+        public void alwaysPasses() {
+        }
+    }
+
+    public static class ThrowingTestRule implements TestRule {
+
+        public Statement apply(
+                Statement base, org.junit.runner.Description description) {
+            new FakeClassUnderTest().throwsExceptionWithoutCause();
+            return base;
+        }
+    }
+
+    public static class TestWithThrowingTestRule {
+
+        @Rule
+        public final TestRule rule = new ThrowingTestRule();
+
+        @Test
+        public void alwaysPasses() {
+        }
+    }
+
+    public static class TestWithThrowingClassRule {
+
+        @ClassRule
+        public static final TestRule rule = new ThrowingTestRule();
+
+        @Test
+        public void alwaysPasses() {
+        }
+    }
+
+    public static class ThrowingMethodRule implements MethodRule {
+
+        public Statement apply(
+                Statement base, FrameworkMethod method, Object target) {
+            new FakeClassUnderTest().throwsExceptionWithoutCause();
+            return base;
+        }
+    }
+
+    public static class TestWithThrowingMethodRule {
+
+        @Rule
+        public final ThrowingMethodRule rule = new ThrowingMethodRule();
+
+        @Test
+        public void alwaysPasses() {
+        }
+    }
+
+    public static class TestWithSuppressedException {
+        public static final Method addSuppressed = initAddSuppressed();
+
+        static Method initAddSuppressed() {
+            try {
+                return Throwable.class.getMethod("addSuppressed", Throwable.class);
+            } catch (Throwable e) {
+                return null;
+            }
+        }
+
+        @Test
+        public void alwaysThrows() throws Exception {
+            final RuntimeException exception = new RuntimeException("error");
+            addSuppressed.invoke(exception, new RuntimeException("suppressed"));
+            throw exception;
+        }
+    }
+
+    private static class FakeClassUnderTest {
+        
+        public void throwsExceptionWithCause() {
+            doThrowExceptionWithCause();
+        }
+
+        public void throwsExceptionWithoutCause() {
+            doThrowExceptionWithoutCause();
+        }
+
+        private void doThrowExceptionWithCause() {
+            try {
+                throwsExceptionWithoutCause();
+            } catch (Exception e) {
+                throw new RuntimeException("outer", e);
+            }
+        }
+
+        private void doThrowExceptionWithoutCause() {
+            throw new RuntimeException("cause");
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/TestSystem.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/TestSystem.java
new file mode 100644
index 0000000..d74166c
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/TestSystem.java
@@ -0,0 +1,35 @@
+package org.junit.tests;
+
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+import org.junit.internal.JUnitSystem;
+
+public class TestSystem implements JUnitSystem {
+    private PrintStream out;
+    public int fCode;
+    private ByteArrayOutputStream fOutContents;
+
+    public TestSystem() {
+        fOutContents = new ByteArrayOutputStream();
+        out = new PrintStream(fOutContents);
+    }
+
+    /**
+     * Will be removed in the next major release
+     */
+    @Deprecated
+    public void exit(int code) {
+        fCode = code;
+    }
+
+    public PrintStream out() {
+        return out;
+    }
+
+    public OutputStream outContents() {
+        return fOutContents;
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/AllAssertionTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/AllAssertionTests.java
new file mode 100644
index 0000000..5190e94
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/AllAssertionTests.java
@@ -0,0 +1,14 @@
+package org.junit.tests.assertion;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AssertionTest.class,
+        ComparisonFailureTest.class,
+        MultipleFailureExceptionTest.class
+})
+public class AllAssertionTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/AssertionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/AssertionTest.java
new file mode 100644
index 0000000..22907e0
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/AssertionTest.java
@@ -0,0 +1,1005 @@
+package org.junit.tests.assertion;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+
+import org.junit.Assert;
+import org.junit.ComparisonFailure;
+import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
+import org.junit.internal.ArrayComparisonFailure;
+
+/**
+ * Tests for {@link org.junit.Assert}
+ */
+public class AssertionTest {
+// If you want to use 1.4 assertions, they will be reported correctly.
+// However, you need to add the -ea VM argument when running.
+
+// @Test (expected=AssertionError.class) public void error() {
+//      assert false;
+//  }
+
+    private static final String ASSERTION_ERROR_EXPECTED = "AssertionError expected";
+
+    @Test(expected = AssertionError.class)
+    public void fails() {
+        Assert.fail();
+    }
+
+    @Test
+    public void failWithNoMessageToString() {
+        try {
+            Assert.fail();
+        } catch (AssertionError exception) {
+            assertEquals("java.lang.AssertionError", exception.toString());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void failWithMessageToString() {
+        try {
+            Assert.fail("woops!");
+        } catch (AssertionError exception) {
+            assertEquals("java.lang.AssertionError: woops!", exception.toString());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void arraysNotEqual() {
+        assertArrayEqualsFailure(
+                new Object[]{"right"},
+                new Object[]{"wrong"},
+                "arrays first differed at element [0]; expected:<[right]> but was:<[wrong]>");
+    }
+
+    @Test
+    public void arraysNotEqualWithMessage() {
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[]{"right"},
+                new Object[]{"wrong"},
+                "not equal: arrays first differed at element [0]; expected:<[right]> but was:<[wrong]>");
+    }
+
+    @Test
+    public void arraysExpectedNullMessage() {
+        try {
+            assertArrayEquals("not equal", null, new Object[]{new Object()});
+        } catch (AssertionError exception) {
+            assertEquals("not equal: expected array was null", exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void arraysActualNullMessage() {
+        try {
+            assertArrayEquals("not equal", new Object[]{new Object()}, null);
+        } catch (AssertionError exception) {
+            assertEquals("not equal: actual array was null", exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void arraysDifferentLengthDifferingAtStartMessage() {
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[]{true},
+                new Object[]{false, true},
+                "not equal: array lengths differed, expected.length=1 actual.length=2; arrays first differed at element [0]; expected:<true> but was:<false>");
+    }
+
+    @Test
+    public void arraysDifferentLengthDifferingAtEndMessage() {
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[]{true},
+                new Object[]{true, false},
+                "not equal: array lengths differed, expected.length=1 actual.length=2; arrays first differed at element [1]; expected:<end of array> but was:<false>");
+    }
+
+    @Test
+    public void arraysDifferentLengthDifferingAtEndAndExpectedArrayLongerMessage() {
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[]{true, false},
+                new Object[]{true},
+                "not equal: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1]; expected:<false> but was:<end of array>");
+    }
+
+    @Test
+    public void arraysElementsDiffer() {
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[]{"this is a very long string in the middle of an array"},
+                new Object[]{"this is another very long string in the middle of an array"},
+                "not equal: arrays first differed at element [0]; expected:<this is a[] very long string in...> but was:<this is a[nother] very long string in...>");
+    }
+
+    @Test
+    public void arraysDifferAtElement0nullMessage() {
+        assertArrayEqualsFailure(
+                new Object[]{true},
+                new Object[]{false},
+                "arrays first differed at element [0]; expected:<true> but was:<false>"
+        );
+    }
+
+    @Test
+    public void arraysDifferAtElement1nullMessage() {
+        assertArrayEqualsFailure(
+                new Object[]{true, true},
+                new Object[]{true, false},
+                "arrays first differed at element [1]; expected:<true> but was:<false>"
+        );
+    }
+
+    @Test
+    public void arraysDifferAtElement0withMessage() {
+        assertArrayEqualsFailure(
+                "message",
+                new Object[]{true},
+                new Object[]{false},
+                "message: arrays first differed at element [0]; expected:<true> but was:<false>"
+        );
+    }
+
+    @Test
+    public void arraysDifferAtElement1withMessage() {
+        assertArrayEqualsFailure(
+                "message",
+                new Object[]{true, true},
+                new Object[]{true, false},
+                "message: arrays first differed at element [1]; expected:<true> but was:<false>"
+        );
+    }
+
+    @Test
+    public void multiDimensionalArraysAreEqual() {
+        assertArrayEquals((new Object[][]{{true, true}, {false, false}}), (new Object[][]{{true, true}, {false, false}}));
+    }
+
+    @Test
+    public void multiDimensionalIntArraysAreEqual() {
+        int[][] int1 = {{1, 2, 3}, {4, 5, 6}};
+        int[][] int2 = {{1, 2, 3}, {4, 5, 6}};
+        assertArrayEquals(int1, int2);
+    }
+
+    @Test
+    public void oneDimensionalPrimitiveArraysAreEqual() {
+        assertArrayEquals(new boolean[]{true}, new boolean[]{true});
+        assertArrayEquals(new byte[]{1}, new byte[]{1});
+        assertArrayEquals(new char[]{1}, new char[]{1});
+        assertArrayEquals(new short[]{1}, new short[]{1});
+        assertArrayEquals(new int[]{1}, new int[]{1});
+        assertArrayEquals(new long[]{1}, new long[]{1});
+        assertArrayEquals(new double[]{1.0}, new double[]{1.0}, 1.0);
+        assertArrayEquals(new float[]{1.0f}, new float[]{1.0f}, 1.0f);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void oneDimensionalDoubleArraysAreNotEqual() {
+        assertArrayEquals(new double[]{1.0}, new double[]{2.5}, 1.0);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void oneDimensionalFloatArraysAreNotEqual() {
+        assertArrayEquals(new float[]{1.0f}, new float[]{2.5f}, 1.0f);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void oneDimensionalBooleanArraysAreNotEqual() {
+        assertArrayEquals(new boolean[]{true}, new boolean[]{false});
+    }
+
+    @Test(expected = AssertionError.class)
+    public void IntegerDoesNotEqualLong() {
+        assertEquals(new Integer(1), new Long(1));
+    }
+
+    @Test
+    public void intsEqualLongs() {
+        assertEquals(1, 1L);
+    }
+
+    @Test
+    public void multiDimensionalArraysDeclaredAsOneDimensionalAreEqual() {
+        assertArrayEquals((new Object[]{new Object[]{true, true}, new Object[]{false, false}}), (new Object[]{new Object[]{true, true}, new Object[]{false, false}}));
+    }
+
+    @Test
+    public void multiDimensionalArraysAreNotEqual() {
+        assertArrayEqualsFailure(
+                "message",
+                new Object[][]{{true, true}, {false, false}},
+                new Object[][]{{true, true}, {true, false}},
+                "message: arrays first differed at element [1][0]; expected:<false> but was:<true>");
+    }
+
+    @Test
+    public void multiDimensionalArraysAreNotEqualNoMessage() {
+        assertArrayEqualsFailure(
+                new Object[][]{{true, true}, {false, false}},
+                new Object[][]{{true, true}, {true, false}},
+                "arrays first differed at element [1][0]; expected:<false> but was:<true>");
+    }
+
+    @Test
+    public void twoDimensionalArraysDifferentOuterLengthNotEqual() {
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[][]{{true}, {}},
+                new Object[][]{{}},
+                "not equal: array lengths differed, expected.length=1 actual.length=0; arrays first differed at element [0][0]; expected:<true> but was:<end of array>");
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[][]{{}, {true}},
+                new Object[][]{{}},
+                "not equal: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1]; expected:<java.lang.Object[1]> but was:<end of array>");
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[][]{{}},
+                new Object[][]{{true}, {}},
+                "not equal: array lengths differed, expected.length=0 actual.length=1; arrays first differed at element [0][0]; expected:<end of array> but was:<true>");
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[][]{{}},
+                new Object[][]{{}, {true}},
+                "not equal: array lengths differed, expected.length=1 actual.length=2; arrays first differed at element [1]; expected:<end of array> but was:<java.lang.Object[1]>");
+    }
+
+    @Test
+    public void primitiveArraysConvertedToStringCorrectly() {
+        assertArrayEqualsFailure(
+                "not equal",
+                new boolean[][]{{}, {true}},
+                new boolean[][]{{}},
+                "not equal: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1]; expected:<boolean[1]> but was:<end of array>");
+        assertArrayEqualsFailure(
+                "not equal",
+                new int[][]{{}, {23}},
+                new int[][]{{}},
+                "not equal: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1]; expected:<int[1]> but was:<end of array>");
+    }
+
+    @Test
+    public void twoDimensionalArraysConvertedToStringCorrectly() {
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[][][]{{}, {{true}}},
+                new Object[][][]{{}},
+                "not equal: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1]; expected:<java.lang.Object[][1]> but was:<end of array>");
+    }
+
+    @Test
+    public void twoDimensionalArraysDifferentInnerLengthNotEqual() {
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[][]{{true}, {}},
+                new Object[][]{{}, {}},
+                "not equal: array lengths differed, expected.length=1 actual.length=0; arrays first differed at element [0][0]; expected:<true> but was:<end of array>");
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[][]{{}, {true}},
+                new Object[][]{{}, {}},
+                "not equal: array lengths differed, expected.length=1 actual.length=0; arrays first differed at element [1][0]; expected:<true> but was:<end of array>");
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[][]{{}, {}},
+                new Object[][]{{true}, {}},
+                "not equal: array lengths differed, expected.length=0 actual.length=1; arrays first differed at element [0][0]; expected:<end of array> but was:<true>");
+        assertArrayEqualsFailure(
+                "not equal",
+                new Object[][]{{}, {}},
+                new Object[][]{{}, {true}},
+                "not equal: array lengths differed, expected.length=0 actual.length=1; arrays first differed at element [1][0]; expected:<end of array> but was:<true>");
+    }
+
+    private void assertArrayEqualsFailure(Object[] expecteds, Object[] actuals, String expectedMessage) {
+        try {
+            assertArrayEquals(expecteds, actuals);
+        } catch (ArrayComparisonFailure e) {
+            assertEquals(expectedMessage, e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    private void assertArrayEqualsFailure(String message, Object[] expecteds, Object[] actuals, String expectedMessage) {
+        try {
+            assertArrayEquals(message, expecteds, actuals);
+        } catch (ArrayComparisonFailure e) {
+            assertEquals(expectedMessage, e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void multiDimensionalArraysDifferentLengthMessage() {
+        try {
+            assertArrayEquals("message", new Object[][]{{true, true}, {false, false}}, new Object[][]{{true, true}, {false}});
+        } catch (AssertionError exception) {
+            assertEquals("message: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1][1]; expected:<false> but was:<end of array>", exception.getMessage());
+            return;
+        }
+
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void multiDimensionalArraysDifferentLengthNoMessage() {
+        try {
+            assertArrayEquals(new Object[][]{{true, true}, {false, false}}, new Object[][]{{true, true}, {false}});
+        } catch (AssertionError exception) {
+            assertEquals("array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1][1]; expected:<false> but was:<end of array>", exception.getMessage());
+            return;
+        }
+
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void arraysWithNullElementEqual() {
+        Object[] objects1 = new Object[]{null};
+        Object[] objects2 = new Object[]{null};
+        assertArrayEquals(objects1, objects2);
+    }
+
+    @Test
+    public void stringsDifferWithUserMessage() {
+        try {
+            assertEquals("not equal", "one", "two");
+        } catch (ComparisonFailure exception) {
+            assertEquals("not equal expected:<[one]> but was:<[two]>", exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void arraysEqual() {
+        Object element = new Object();
+        Object[] objects1 = new Object[]{element};
+        Object[] objects2 = new Object[]{element};
+        assertArrayEquals(objects1, objects2);
+    }
+
+    @Test
+    public void arraysEqualWithMessage() {
+        Object element = new Object();
+        Object[] objects1 = new Object[]{element};
+        Object[] objects2 = new Object[]{element};
+        assertArrayEquals("equal", objects1, objects2);
+    }
+
+    @Test
+    public void equals() {
+        Object o = new Object();
+        assertEquals(o, o);
+        assertEquals("abc", "abc");
+        assertEquals(true, true);
+        assertEquals((byte) 1, (byte) 1);
+        assertEquals('a', 'a');
+        assertEquals((short) 1, (short) 1);
+        assertEquals(1, 1); // int by default, cast is unnecessary
+        assertEquals(1l, 1l);
+        assertEquals(1.0, 1.0, 0.0);
+        assertEquals(1.0d, 1.0d, 0.0d);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void notEqualsObjectWithNull() {
+        assertEquals(new Object(), null);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void notEqualsNullWithObject() {
+        assertEquals(null, new Object());
+    }
+
+    @Test
+    public void notEqualsObjectWithNullWithMessage() {
+        Object o = new Object();
+        try {
+            assertEquals("message", null, o);
+        } catch (AssertionError e) {
+            assertEquals("message expected:<null> but was:<" + o.toString() + ">", e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void notEqualsNullWithObjectWithMessage() {
+        Object o = new Object();
+        try {
+            assertEquals("message", o, null);
+        } catch (AssertionError e) {
+            assertEquals("message expected:<" + o.toString() + "> but was:<null>", e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void objectsNotEquals() {
+        assertEquals(new Object(), new Object());
+    }
+
+    @Test(expected = ComparisonFailure.class)
+    public void stringsNotEqual() {
+        assertEquals("abc", "def");
+    }
+
+    @Test(expected = AssertionError.class)
+    public void booleansNotEqual() {
+        assertEquals(true, false);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void bytesNotEqual() {
+        assertEquals((byte) 1, (byte) 2);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void charsNotEqual() {
+        assertEquals('a', 'b');
+    }
+
+    @Test(expected = AssertionError.class)
+    public void shortsNotEqual() {
+        assertEquals((short) 1, (short) 2);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void intsNotEqual() {
+        assertEquals(1, 2);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void longsNotEqual() {
+        assertEquals(1l, 2l);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void floatsNotEqual() {
+        assertEquals(1.0, 2.0, 0.9);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test(expected = AssertionError.class)
+    public void floatsNotEqualWithoutDelta() {
+        assertEquals(1.0, 1.1);
+    }
+
+    @Test
+    public void floatsNotDoublesInArrays() {
+        float delta = 4.444f;
+        float[] f1 = new float[]{1.111f};
+        float[] f2 = new float[]{5.555f};
+        Assert.assertArrayEquals(f1, f2, delta);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void bigDecimalsNotEqual() {
+        assertEquals(new BigDecimal("123.4"), new BigDecimal("123.0"));
+    }
+
+
+    @Test(expected = AssertionError.class)
+    public void doublesNotEqual() {
+        assertEquals(1.0d, 2.0d, 0.9d);
+    }
+
+    @Test
+    public void naNsAreEqual() {
+        assertEquals(Float.NaN, Float.NaN, Float.POSITIVE_INFINITY);
+        assertEquals(Double.NaN, Double.NaN, Double.POSITIVE_INFINITY);
+    }
+
+    @SuppressWarnings("unused")
+    @Test
+    public void nullNullmessage() {
+        try {
+            assertNull("junit");
+        } catch (AssertionError e) {
+            assertEquals("expected null, but was:<junit>", e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @SuppressWarnings("unused")
+    @Test
+    public void nullWithMessage() {
+        try {
+            assertNull("message", "hello");
+        } catch (AssertionError exception) {
+            assertEquals("message expected null, but was:<hello>", exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void same() {
+        Object o1 = new Object();
+        assertSame(o1, o1);
+    }
+
+    @Test
+    public void notSame() {
+        Object o1 = new Object();
+        Object o2 = new Object();
+        assertNotSame(o1, o2);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void objectsNotSame() {
+        assertSame(new Object(), new Object());
+    }
+
+    @Test(expected = AssertionError.class)
+    public void objectsAreSame() {
+        Object o = new Object();
+        assertNotSame(o, o);
+    }
+
+    @Test
+    public void sameWithMessage() {
+        try {
+            assertSame("not same", "hello", "good-bye");
+        } catch (AssertionError exception) {
+            assertEquals("not same expected same:<hello> was not:<good-bye>",
+                    exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void sameNullMessage() {
+        try {
+            assertSame("hello", "good-bye");
+        } catch (AssertionError exception) {
+            assertEquals("expected same:<hello> was not:<good-bye>", exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void notSameWithMessage() {
+        Object o = new Object();
+        try {
+            assertNotSame("message", o, o);
+        } catch (AssertionError exception) {
+            assertEquals("message expected not same", exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void notSameNullMessage() {
+        Object o = new Object();
+        try {
+            assertNotSame(o, o);
+        } catch (AssertionError exception) {
+            assertEquals("expected not same", exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void nullMessage() {
+        try {
+            fail(null);
+        } catch (AssertionError exception) {
+            // we used to expect getMessage() to return ""; see failWithNoMessageToString()
+            assertNull(exception.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void nullMessageDisappearsWithStringAssertEquals() {
+        try {
+            assertEquals(null, "a", "b");
+        } catch (ComparisonFailure e) {
+            assertEquals("expected:<[a]> but was:<[b]>", e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void nullMessageDisappearsWithAssertEquals() {
+        try {
+            assertEquals(null, 1, 2);
+        } catch (AssertionError e) {
+            assertEquals("expected:<1> but was:<2>", e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void arraysDeclaredAsObjectAreComparedAsObjects() {
+        Object a1 = new Object[]{"abc"};
+        Object a2 = new Object[]{"abc"};
+        assertEquals(a1, a2);
+    }
+
+    @Test
+    public void implicitTypecastEquality() {
+        byte b = 1;
+        short s = 1;
+        int i = 1;
+        long l = 1L;
+        float f = 1.0f;
+        double d = 1.0;
+
+        assertEquals(b, s);
+        assertEquals(b, i);
+        assertEquals(b, l);
+        assertEquals(s, i);
+        assertEquals(s, l);
+        assertEquals(i, l);
+        assertEquals(f, d, 0);
+    }
+
+    @Test
+    public void errorMessageDistinguishesDifferentValuesWithSameToString() {
+        try {
+            assertEquals("4", new Integer(4));
+        } catch (AssertionError e) {
+            assertEquals("expected: java.lang.String<4> but was: java.lang.Integer<4>", e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertThatIncludesDescriptionOfTestedValueInErrorMessage() {
+        String expected = "expected";
+        String actual = "actual";
+
+        String expectedMessage = "identifier\nExpected: \"expected\"\n     but: was \"actual\"";
+
+        try {
+            assertThat("identifier", actual, equalTo(expected));
+        } catch (AssertionError e) {
+            assertEquals(expectedMessage, e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertThatIncludesAdvancedMismatch() {
+        String expectedMessage = "identifier\nExpected: is an instance of java.lang.Integer\n     but: \"actual\" is a java.lang.String";
+
+        try {
+            assertThat("identifier", "actual", is(instanceOf(Integer.class)));
+        } catch (AssertionError e) {
+            assertEquals(expectedMessage, e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertThatDescriptionCanBeElided() {
+        String expected = "expected";
+        String actual = "actual";
+
+        String expectedMessage = "\nExpected: \"expected\"\n     but: was \"actual\"";
+
+        try {
+            assertThat(actual, equalTo(expected));
+        } catch (AssertionError e) {
+            assertEquals(expectedMessage, e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void nullAndStringNullPrintCorrectError() {
+        try {
+            assertEquals(null, "null");
+        } catch (AssertionError e) {
+            assertEquals("expected: null<null> but was: java.lang.String<null>", e.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void stringNullAndNullWorksToo() {
+        assertEquals("null", null);
+    }
+
+    private static class NullToString {
+        @Override
+        public String toString() {
+            return null;
+        }
+    }
+
+    @Test
+    public void nullToString() {
+        try {
+            assertEquals(new NullToString(), new NullToString());
+        } catch (AssertionError e) {
+            assertEquals("expected: org.junit.tests.assertion.AssertionTest$NullToString<null> but "
+                            + "was: org.junit.tests.assertion.AssertionTest$NullToString<null>",
+                    e.getMessage());
+            return;
+        }
+
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void compareBigDecimalAndInteger() {
+        final BigDecimal bigDecimal = new BigDecimal("1.2");
+        final Integer integer = Integer.valueOf("1");
+        assertEquals(bigDecimal, integer);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void sameObjectIsNotEqual() {
+        Object o = new Object();
+        assertNotEquals(o, o);
+    }
+
+    @Test
+    public void objectsWithDifferentReferencesAreNotEqual() {
+        assertNotEquals(new Object(), new Object());
+    }
+
+    @Test
+    public void assertNotEqualsIncludesCorrectMessage() {
+        Integer value1 = new Integer(1);
+        Integer value2 = new Integer(1);
+        String message = "The values should be different";
+
+        try {
+            assertNotEquals(message, value1, value2);
+        } catch (AssertionError e) {
+            assertEquals(message + ". Actual: " + value1, e.getMessage());
+            return;
+        }
+
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertNotEqualsIncludesTheValueBeingTested() {
+        Integer value1 = new Integer(1);
+        Integer value2 = new Integer(1);
+
+        try {
+            assertNotEquals(value1, value2);
+        } catch (AssertionError e) {
+            assertTrue(e.getMessage().contains(value1.toString()));
+            return;
+        }
+
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertNotEqualsWorksWithPrimitiveTypes() {
+        assertNotEquals(1L, 2L);
+        assertNotEquals("The values should be different", 1L, 2L);
+        assertNotEquals(1.0, 2.0, 0);
+        assertNotEquals("The values should be different", 1.0, 2.0, 0);
+        assertNotEquals(1.0f, 2.0f, 0f);
+        assertNotEquals("The values should be different", 1.0f, 2.0f, 0f);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void assertNotEqualsConsidersDeltaCorrectly() {
+        assertNotEquals(1.0, 0.9, 0.1);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void assertNotEqualsConsidersFloatDeltaCorrectly() {
+        assertNotEquals(1.0f, 0.75f, 0.25f);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void assertNotEqualsIgnoresDeltaOnNaN() {
+        assertNotEquals(Double.NaN, Double.NaN, 1);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void assertNotEqualsIgnoresFloatDeltaOnNaN() {
+        assertNotEquals(Float.NaN, Float.NaN, 1f);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void assertThrowsRequiresAnExceptionToBeThrown() {
+        assertThrows(Throwable.class, nonThrowingRunnable());
+    }
+
+    @Test
+    public void assertThrowsIncludesAnInformativeDefaultMessage() {
+        try {
+            assertThrows(Throwable.class, nonThrowingRunnable());
+        } catch (AssertionError ex) {
+            assertEquals("expected java.lang.Throwable to be thrown, but nothing was thrown", ex.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertThrowsIncludesTheSpecifiedMessage() {
+        try {
+            assertThrows("Foobar", Throwable.class, nonThrowingRunnable());
+        } catch (AssertionError ex) {
+            assertEquals(
+                    "Foobar: expected java.lang.Throwable to be thrown, but nothing was thrown",
+                    ex.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertThrowsReturnsTheSameObjectThrown() {
+        NullPointerException npe = new NullPointerException();
+
+        Throwable throwable = assertThrows(Throwable.class, throwingRunnable(npe));
+
+        assertSame(npe, throwable);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void assertThrowsDetectsTypeMismatchesViaExplicitTypeHint() {
+        NullPointerException npe = new NullPointerException();
+
+        assertThrows(IOException.class, throwingRunnable(npe));
+    }
+
+    @Test
+    public void assertThrowsWrapsAndPropagatesUnexpectedExceptions() {
+        NullPointerException npe = new NullPointerException("inner-message");
+
+        try {
+            assertThrows(IOException.class, throwingRunnable(npe));
+        } catch (AssertionError ex) {
+            assertSame(npe, ex.getCause());
+            assertEquals("inner-message", ex.getCause().getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertThrowsSuppliesACoherentErrorMessageUponTypeMismatch() {
+        NullPointerException npe = new NullPointerException();
+
+        try {
+            assertThrows(IOException.class, throwingRunnable(npe));
+        } catch (AssertionError error) {
+            assertEquals("unexpected exception type thrown; expected:<java.io.IOException> but was:<java.lang.NullPointerException>",
+                    error.getMessage());
+            assertSame(npe, error.getCause());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertThrowsSuppliesTheSpecifiedMessageUponTypeMismatch() {
+        NullPointerException npe = new NullPointerException();
+
+        try {
+            assertThrows("Foobar", IOException.class, throwingRunnable(npe));
+        } catch (AssertionError error) {
+            assertEquals("Foobar: unexpected exception type thrown; expected:<java.io.IOException> but was:<java.lang.NullPointerException>",
+                    error.getMessage());
+            assertSame(npe, error.getCause());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertThrowsUsesCanonicalNameUponTypeMismatch() {
+        NullPointerException npe = new NullPointerException();
+
+        try {
+            assertThrows(NestedException.class, throwingRunnable(npe));
+        } catch (AssertionError error) {
+            assertEquals(
+                    "unexpected exception type thrown; expected:<org.junit.tests.assertion.AssertionTest.NestedException>"
+                    + " but was:<java.lang.NullPointerException>",
+                    error.getMessage());
+            assertSame(npe, error.getCause());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertThrowsUsesNameUponTypeMismatchWithAnonymousClass() {
+        NullPointerException npe = new NullPointerException() {
+        };
+
+        try {
+            assertThrows(IOException.class, throwingRunnable(npe));
+        } catch (AssertionError error) {
+            assertEquals(
+                    "unexpected exception type thrown; expected:<java.io.IOException>"
+                    + " but was:<org.junit.tests.assertion.AssertionTest$1>",
+                    error.getMessage());
+            assertSame(npe, error.getCause());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    @Test
+    public void assertThrowsUsesCanonicalNameWhenRequiredExceptionNotThrown() {
+        try {
+            assertThrows(NestedException.class, nonThrowingRunnable());
+        } catch (AssertionError error) {
+            assertEquals(
+                    "expected org.junit.tests.assertion.AssertionTest.NestedException to be thrown,"
+                    + " but nothing was thrown", error.getMessage());
+            return;
+        }
+        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
+    }
+
+    private static class NestedException extends RuntimeException {
+        private static final long serialVersionUID = 1L;
+    }
+
+    private static ThrowingRunnable nonThrowingRunnable() {
+        return new ThrowingRunnable() {
+            public void run() throws Throwable {
+            }
+        };
+    }
+
+    private static ThrowingRunnable throwingRunnable(final Throwable t) {
+        return new ThrowingRunnable() {
+            public void run() throws Throwable {
+                throw t;
+            }
+        };
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/ComparisonFailureTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/ComparisonFailureTest.java
new file mode 100644
index 0000000..17ff2af
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/ComparisonFailureTest.java
@@ -0,0 +1,78 @@
+package org.junit.tests.assertion;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.ComparisonFailure;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ComparisonFailureTest {
+		
+	private String expected, actual, message;
+	
+	public ComparisonFailureTest(String e, String a, String m) {
+		expected = e;
+		actual = a;
+		message = m;
+	}
+	
+	@Parameters(name = "compact-msg-{index}, exp=\"{1}\"")
+	public static Collection<Object[]> data() {
+		return Arrays.asList(new Object[][] {
+			// simple base case
+			{ "a", "b", "expected:<[a]> but was:<[b]>" },
+				
+			// common prefix
+			{ "ba", "bc", "expected:<b[a]> but was:<b[c]>" },
+				
+			// common suffix
+			{ "ab", "cb", "expected:<[a]b> but was:<[c]b>" },
+				
+			// common pre and suffix
+			{ "abc", "adc", "expected:<a[b]c> but was:<a[d]c>" },
+			
+			// expected is subset of actual
+			{ "ab", "abc", "expected:<ab[]> but was:<ab[c]>" },
+
+			// expected is superset of actual
+			{ "abc", "ab", "expected:<ab[c]> but was:<ab[]>" },
+			
+			// overlapping matches.
+			{ "abc", "abbc", "expected:<ab[]c> but was:<ab[b]c>" },
+
+			// long prefix yielding "..."
+			{ "01234567890123456789PRE:hello:POST", 
+				"01234567890123456789PRE:world:POST",
+				"expected:<...4567890123456789PRE:[hello]:POST> but was:<...4567890123456789PRE:[world]:POST>" },
+					
+			// long suffix	yielding "..."
+			{ "PRE:hello:01234567890123456789POST",
+				"PRE:world:01234567890123456789POST",
+				"expected:<PRE:[hello]:0123456789012345678...> but was:<PRE:[world]:0123456789012345678...>"	
+			},
+					
+			// bug609972
+			{ "S&P500", "0", "expected:<[S&P50]0> but was:<[]0>" },
+			
+			// empty expected string
+			{ "", "a", "expected:<[]> but was:<[a]>" },
+
+			// empty actual string
+			{ "a", "", "expected:<[a]> but was:<[]>" }
+
+		});	
+	}
+
+	@Test
+	public void compactFailureMessage() {
+		ComparisonFailure failure = new ComparisonFailure("", expected, actual);
+		assertEquals(message, failure.getMessage());
+	}
+	
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/MultipleFailureExceptionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/MultipleFailureExceptionTest.java
new file mode 100644
index 0000000..18880b7
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/assertion/MultipleFailureExceptionTest.java
@@ -0,0 +1,118 @@
+package org.junit.tests.assertion;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.lang.annotation.AnnotationFormatError;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Test;
+import org.junit.TestCouldNotBeSkippedException;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runners.model.MultipleFailureException;
+
+
+/**
+ * Tests for {@link org.junit.runners.model.MultipleFailureException}
+ *
+ * @author kcooney@google.com (Kevin Cooney)
+ */
+public class MultipleFailureExceptionTest {
+    private static final String LINE_SEPARATOR = System.getProperty("line.separator");
+
+    @Test
+    public void assertEmptyDoesNotThrowForEmptyList() throws Exception {
+        MultipleFailureException.assertEmpty(Collections.<Throwable>emptyList());
+    }
+
+    @Test
+    public void assertEmptyRethrowsSingleRuntimeException() throws Exception {
+        Throwable exception= new ExpectedException("pesto");
+        List<Throwable> errors= Collections.singletonList(exception);
+        try {
+            MultipleFailureException.assertEmpty(errors);
+            fail();
+        } catch (ExpectedException e) {
+            assertSame(e, exception);
+        }
+    }
+
+    @Test
+    public void assertEmptyRethrowsSingleError() throws Exception {
+        Throwable exception= new AnnotationFormatError("changeo");
+        List<Throwable> errors= Collections.singletonList(exception);
+        try {
+            MultipleFailureException.assertEmpty(errors);
+            fail();
+        } catch (AnnotationFormatError e) {
+            assertSame(e, exception);
+        }
+    }
+
+    @Test
+    public void assertEmptyThrowsMultipleFailureExceptionForManyThrowables() throws Exception {
+        List<Throwable> errors = new ArrayList<Throwable>();
+        errors.add(new ExpectedException("basil"));
+        errors.add(new RuntimeException("garlic"));
+
+        try {
+            MultipleFailureException.assertEmpty(errors);
+            fail();
+        } catch (MultipleFailureException expected) {
+            assertThat(expected.getFailures(), equalTo(errors));
+            assertTrue(expected.getMessage().startsWith("There were 2 errors:" + LINE_SEPARATOR));
+            assertTrue(expected.getMessage().contains("ExpectedException(basil)" + LINE_SEPARATOR));
+            assertTrue(expected.getMessage().contains("RuntimeException(garlic)"));
+        }
+    }
+
+    @Test
+    public void assertEmptyErrorListConstructorFailure() {
+        try {
+            new MultipleFailureException(Collections.<Throwable>emptyList());
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertThat(expected.getMessage(),
+                    containsString("List of Throwables must not be empty"));
+        }
+    }
+
+    @Test
+    public void assertEmptyWrapsAssumptionFailuresForManyThrowables() throws Exception {
+        List<Throwable> errors = new ArrayList<Throwable>();
+        AssumptionViolatedException assumptionViolatedException = new AssumptionViolatedException("skip it");
+        errors.add(assumptionViolatedException);
+        errors.add(new RuntimeException("garlic"));
+
+        try {
+            MultipleFailureException.assertEmpty(errors);
+            fail();
+        } catch (MultipleFailureException expected) {
+            assertThat(expected.getFailures().size(), equalTo(2));
+            assertTrue(expected.getMessage().startsWith("There were 2 errors:" + LINE_SEPARATOR));
+            assertTrue(expected.getMessage().contains("TestCouldNotBeSkippedException(Test could not be skipped"));
+            assertTrue(expected.getMessage().contains("RuntimeException(garlic)"));
+            Throwable first = expected.getFailures().get(0);
+            assertThat(first, instanceOf(TestCouldNotBeSkippedException.class));
+            Throwable cause = ((TestCouldNotBeSkippedException) first).getCause();
+            assertThat(cause, instanceOf(AssumptionViolatedException.class));
+            assertThat((AssumptionViolatedException) cause, CoreMatchers.sameInstance(assumptionViolatedException));
+        }
+    }
+
+    private static class ExpectedException extends RuntimeException {
+        private static final long serialVersionUID = 1L;
+
+        public ExpectedException(String message) {
+            super(message);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/deprecated/AllDeprecatedTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/deprecated/AllDeprecatedTests.java
new file mode 100644
index 0000000..4e1a3f4
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/deprecated/AllDeprecatedTests.java
@@ -0,0 +1,13 @@
+package org.junit.tests.deprecated;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@SuppressWarnings("deprecation")
+@RunWith(Suite.class)
+@SuiteClasses({
+        JUnit4ClassRunnerTest.class
+})
+public class AllDeprecatedTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/deprecated/JUnit4ClassRunnerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/deprecated/JUnit4ClassRunnerTest.java
new file mode 100644
index 0000000..c0c081d
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/deprecated/JUnit4ClassRunnerTest.java
@@ -0,0 +1,64 @@
+package org.junit.tests.deprecated;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.internal.runners.JUnit4ClassRunner;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+
+/**
+ * @deprecated This is a simple smoke test to make sure the old JUnit4ClassRunner basically works.
+ *             Delete this test when JUnit4ClassRunner goes to the Great Heap In The Sky.
+ */
+@Deprecated
+public class JUnit4ClassRunnerTest {
+
+    @SuppressWarnings("deprecation")
+    @RunWith(JUnit4ClassRunner.class)
+    public static class Example {
+        @Test
+        public void success() {
+        }
+
+        @Test
+        public void failure() {
+            fail();
+        }
+    }
+
+    @Test
+    public void runWithOldJUnit4ClassRunner() {
+        Result result = JUnitCore.runClasses(Example.class);
+        assertThat(result.getRunCount(), is(2));
+        assertThat(result.getFailureCount(), is(1));
+    }
+
+    @SuppressWarnings("deprecation")
+    @RunWith(JUnit4ClassRunner.class)
+    public static class UnconstructableExample {
+        public UnconstructableExample() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Test
+        public void success() {
+        }
+
+        @Test
+        public void failure() {
+            fail();
+        }
+    }
+
+
+    @Test
+    public void runWithOldJUnit4ClassRunnerAndBadConstructor() {
+        Result result = JUnitCore.runClasses(UnconstructableExample.class);
+        assertThat(result.getRunCount(), is(2));
+        assertThat(result.getFailureCount(), is(2));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/description/AllDescriptionTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/description/AllDescriptionTests.java
new file mode 100644
index 0000000..6de5efb
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/description/AllDescriptionTests.java
@@ -0,0 +1,15 @@
+package org.junit.tests.description;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AnnotatedDescriptionTest.class,
+        SuiteDescriptionTest.class,
+        TestDescriptionMethodNameTest.class,
+        TestDescriptionTest.class
+})
+public class AllDescriptionTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/description/AnnotatedDescriptionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/description/AnnotatedDescriptionTest.java
new file mode 100644
index 0000000..cbe3522
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/description/AnnotatedDescriptionTest.java
@@ -0,0 +1,96 @@
+package org.junit.tests.description;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.Request;
+
+public class AnnotatedDescriptionTest {
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MyOwnAnnotation {
+
+    }
+
+    @MyOwnAnnotation
+    public static class AnnotatedClass {
+        @Test
+        public void a() {
+        }
+    }
+
+    @Test
+    public void annotationsExistOnDescriptionsOfClasses() {
+        assertTrue((describe(AnnotatedClass.class).getAnnotation(
+                MyOwnAnnotation.class) != null));
+    }
+
+    @Test
+    public void getAnnotationsReturnsAllAnnotations() {
+        assertEquals(1, describe(ValueAnnotatedClass.class).getAnnotations()
+                .size());
+    }
+
+    @Ignore
+    public static class IgnoredClass {
+        @Test
+        public void a() {
+        }
+    }
+
+    @Test
+    public void annotationsExistOnDescriptionsOfIgnoredClass() {
+        assertTrue((describe(IgnoredClass.class).getAnnotation(Ignore.class) != null));
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface ValuedAnnotation {
+        String value();
+    }
+
+    @ValuedAnnotation("hello")
+    public static class ValueAnnotatedClass {
+        @Test
+        public void a() {
+        }
+    }
+
+    @Test
+    public void descriptionOfTestClassHasValuedAnnotation() {
+        Description description = describe(ValueAnnotatedClass.class);
+        assertEquals("hello", description.getAnnotation(ValuedAnnotation.class)
+                .value());
+    }
+
+    @Test
+    public void childlessCopyOfDescriptionStillHasAnnotations() {
+        Description description = describe(ValueAnnotatedClass.class);
+        assertEquals("hello", description.childlessCopy().getAnnotation(ValuedAnnotation.class)
+                .value());
+    }
+
+    @Test
+    public void characterizeCreatingMyOwnAnnotation() {
+        Annotation annotation = new Ignore() {
+            public String value() {
+                return "message";
+            }
+
+            public Class<? extends Annotation> annotationType() {
+                return Ignore.class;
+            }
+        };
+
+        assertEquals(Ignore.class, annotation.annotationType());
+    }
+
+    private Description describe(Class<?> testClass) {
+        return Request.aClass(testClass).getRunner().getDescription();
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/description/SuiteDescriptionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/description/SuiteDescriptionTest.java
new file mode 100644
index 0000000..5b17d1e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/description/SuiteDescriptionTest.java
@@ -0,0 +1,38 @@
+package org.junit.tests.description;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+
+public class SuiteDescriptionTest {
+    Description childless = Description.createSuiteDescription("a");
+    Description anotherChildless = Description.createSuiteDescription("a");
+    Description namedB = Description.createSuiteDescription("b");
+
+    Description twoKids = descriptionWithTwoKids("foo", "bar");
+    Description anotherTwoKids = descriptionWithTwoKids("foo", "baz");
+
+    @Test
+    public void equalsIsCorrect() {
+        assertEquals(childless, anotherChildless);
+        assertFalse(childless.equals(namedB));
+        assertEquals(childless, twoKids);
+        assertEquals(twoKids, anotherTwoKids);
+        assertFalse(twoKids.equals(new Integer(5)));
+    }
+
+    @Test
+    public void hashCodeIsReasonable() {
+        assertEquals(childless.hashCode(), anotherChildless.hashCode());
+        assertFalse(childless.hashCode() == namedB.hashCode());
+    }
+
+    private Description descriptionWithTwoKids(String first, String second) {
+        Description twoKids = Description.createSuiteDescription("a");
+        twoKids.addChild(Description.createTestDescription(getClass(), first));
+        twoKids.addChild(Description.createTestDescription(getClass(), second));
+        return twoKids;
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/description/TestDescriptionMethodNameTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/description/TestDescriptionMethodNameTest.java
new file mode 100644
index 0000000..21943e9
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/description/TestDescriptionMethodNameTest.java
@@ -0,0 +1,50 @@
+package org.junit.tests.description;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/**
+ * @author Dmitry Baev charlie@yandex-team.ru
+ *         Date: 03.05.14
+ */
+@RunWith(Parameterized.class)
+public class TestDescriptionMethodNameTest {
+
+    private String methodName;
+
+    public TestDescriptionMethodNameTest(String methodName) {
+        this.methodName = methodName;
+    }
+
+    @Parameterized.Parameters
+    public static Collection<Object[]> getMethodNames() {
+        return Arrays.asList(
+                new Object[]{"simple"},
+                new Object[]{"with space"},
+                new Object[]{"[]!@#$%^&*()"},
+                new Object[]{""},
+                new Object[]{"\t"},
+                new Object[]{"\n"},
+                new Object[]{"\r\n"},
+                new Object[]{"\r"},
+                new Object[]{"\u0085"},
+                new Object[]{"\u2028"},
+                new Object[]{"\u2029"}
+        );
+    }
+
+    @Test
+    public void methodNameTest() throws Exception {
+        Description description = Description.createTestDescription("some-class-name", methodName);
+        assertNotNull("Method name should be not null", description.getMethodName());
+        assertEquals(methodName, description.getMethodName());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/description/TestDescriptionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/description/TestDescriptionTest.java
new file mode 100644
index 0000000..3bc07f4
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/description/TestDescriptionTest.java
@@ -0,0 +1,24 @@
+package org.junit.tests.description;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+
+public class TestDescriptionTest {
+    @Test
+    public void equalsIsFalseForNonTestDescription() {
+        assertFalse(Description.createTestDescription(getClass(), "a").equals(new Integer(5)));
+    }
+
+    @Test
+    public void equalsIsTrueForSameNameAndNoExplicitUniqueId() {
+        assertTrue(Description.createSuiteDescription("Hello").equals(Description.createSuiteDescription("Hello")));
+    }
+
+    @Test
+    public void equalsIsFalseForSameNameAndDifferentUniqueId() {
+        assertFalse(Description.createSuiteDescription("Hello", 2).equals(Description.createSuiteDescription("Hello", 3)));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/AllExperimentalTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/AllExperimentalTests.java
new file mode 100644
index 0000000..b20ae9d
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/AllExperimentalTests.java
@@ -0,0 +1,25 @@
+package org.junit.tests.experimental;
+
+import org.junit.experimental.categories.AllCategoriesTests;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+import org.junit.tests.experimental.max.AllMaxTests;
+import org.junit.tests.experimental.parallel.AllParallelTests;
+import org.junit.tests.experimental.results.AllResultsTests;
+import org.junit.tests.experimental.theories.AllTheoriesTests;
+import org.junit.tests.experimental.theories.extendingwithstubs.StubbedTheoriesTest;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AllCategoriesTests.class,
+        AllMaxTests.class,
+        AllParallelTests.class,
+        AllResultsTests.class,
+        AllTheoriesTests.class,
+        AssumptionTest.class,
+        MatcherTest.class,
+        StubbedTheoriesTest.class
+})
+public class AllExperimentalTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/AssumptionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/AssumptionTest.java
new file mode 100644
index 0000000..e011619
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/AssumptionTest.java
@@ -0,0 +1,312 @@
+package org.junit.tests.experimental;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeNoException;
+import static org.junit.Assume.assumeNotNull;
+import static org.junit.Assume.assumeThat;
+import static org.junit.Assume.assumeTrue;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Assume;
+import org.junit.AssumptionViolatedException;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+
+public class AssumptionTest {
+    public static class HasFailingAssumption {
+        @Test
+        public void assumptionsFail() {
+            assumeThat(3, is(4));
+            fail();
+        }
+    }
+
+    @Test
+    public void failedAssumptionsMeanPassing() {
+        Result result = JUnitCore.runClasses(HasFailingAssumption.class);
+        assertThat(result.getRunCount(), is(1));
+        assertThat(result.getIgnoreCount(), is(0));
+        assertThat(result.getFailureCount(), is(0));
+    }
+
+    private static int assumptionFailures = 0;
+
+    @Test
+    public void failedAssumptionsCanBeDetectedByListeners() {
+        assumptionFailures = 0;
+        JUnitCore core = new JUnitCore();
+        core.addListener(new RunListener() {
+            @Override
+            public void testAssumptionFailure(Failure failure) {
+                assumptionFailures++;
+            }
+        });
+        core.run(HasFailingAssumption.class);
+
+        assertThat(assumptionFailures, is(1));
+    }
+
+    public static class HasPassingAssumption {
+        @Test
+        public void assumptionsFail() {
+            assumeThat(3, is(3));
+            fail();
+        }
+    }
+
+    @Test
+    public void passingAssumptionsScootThrough() {
+        Result result = JUnitCore.runClasses(HasPassingAssumption.class);
+        assertThat(result.getRunCount(), is(1));
+        assertThat(result.getIgnoreCount(), is(0));
+        assertThat(result.getFailureCount(), is(1));
+    }
+
+    @Test
+    public void assumeThatWorks() {
+        try {
+            assumeThat(1, is(2));
+            fail("should throw AssumptionViolatedException");
+        } catch (AssumptionViolatedException e) {
+            // expected
+        }
+    }
+
+    @Test
+    public void assumeThatPasses() {
+        assumeThat(1, is(1));
+        assertCompletesNormally();
+    }
+
+    @Test
+    public void assumeThatPassesOnStrings() {
+        assumeThat("x", is("x"));
+        assertCompletesNormally();
+    }
+
+    @Test
+    public void assumeNotNullThrowsException() {
+        Object[] objects = {1, 2, null};
+        try {
+            assumeNotNull(objects);
+            fail("should throw AssumptionViolatedException");
+        } catch (AssumptionViolatedException e) {
+            // expected
+        }
+    }
+
+    @Test
+    public void assumeNotNullThrowsExceptionForNullArray() {
+        try {
+            assumeNotNull((Object[]) null);
+            fail("should throw AssumptionViolatedException");
+        } catch (AssumptionViolatedException e) {
+            // expected
+        }
+    }
+
+    @Test
+    public void assumeNotNullPasses() {
+        Object[] objects = {1, 2};
+        assumeNotNull(objects);
+        assertCompletesNormally();
+    }
+
+    @Test
+    public void assumeNotNullIncludesParameterList() {
+        try {
+            Object[] objects = {1, 2, null};
+            assumeNotNull(objects);
+        } catch (AssumptionViolatedException e) {
+            assertThat(e.getMessage(), containsString("1, 2, null"));
+        } catch (Exception e) {
+            fail("Should have thrown AssumptionViolatedException");
+        }
+    }
+
+    @Test
+    public void assumeNoExceptionThrows() {
+        final Throwable exception = new NullPointerException();
+        try {
+            assumeNoException(exception);
+            fail("Should have thrown exception");
+        } catch (AssumptionViolatedException e) {
+            assertThat(e.getCause(), is(exception));
+        }
+    }
+
+    private void assertCompletesNormally() {
+    }
+
+    @Test
+    public void assumeTrueWorks() {
+        try {
+            Assume.assumeTrue(false);
+            fail("should throw AssumptionViolatedException");
+        } catch (AssumptionViolatedException e) {
+            assertEquals("got: <false>, expected: is <true>", e.getMessage());
+        }
+    }
+
+    @Test
+    public void assumeFalseWorks() {
+        try {
+            Assume.assumeFalse(true);
+            fail("should throw AssumptionViolatedException");
+        } catch (AssumptionViolatedException e) {
+            assertEquals("got: <true>, expected: is <false>", e.getMessage());
+        }
+    }
+
+    public static class HasFailingAssumeInBefore {
+        @Before
+        public void checkForSomethingThatIsntThere() {
+            assumeTrue(false);
+        }
+
+        @Test
+        public void failing() {
+            fail();
+        }
+    }
+
+    @Test
+    public void failingAssumptionInBeforePreventsTestRun() {
+        assertThat(testResult(HasFailingAssumeInBefore.class), isSuccessful());
+    }
+
+    public static class HasFailingAssumeInBeforeClass {
+        @BeforeClass
+        public static void checkForSomethingThatIsntThere() {
+            assumeTrue(false);
+        }
+
+        @Test
+        public void failing() {
+            fail();
+        }
+    }
+
+    @Test
+    public void failingAssumptionInBeforeClassIgnoresClass() {
+        assertThat(testResult(HasFailingAssumeInBeforeClass.class), isSuccessful());
+    }
+
+    public static class AssumptionFailureInConstructor {
+        public AssumptionFailureInConstructor() {
+            assumeTrue(false);
+        }
+
+        @Test
+        public void shouldFail() {
+            fail();
+        }
+    }
+
+    @Test
+    public void failingAssumptionInConstructorIgnoresClass() {
+        assertThat(testResult(AssumptionFailureInConstructor.class), isSuccessful());
+    }
+
+    public static class TestClassWithAssumptionFailure {
+
+        @Test(expected = IllegalArgumentException.class)
+        public void assumeWithExpectedException() {
+            assumeTrue(false);
+        }
+    }
+
+    @Test
+    public void assumeWithExpectedExceptionShouldThrowAssumptionViolatedException() {
+        Result result = JUnitCore.runClasses(TestClassWithAssumptionFailure.class);
+        assertThat(result.getAssumptionFailureCount(), is(1));
+    }
+
+    static final String message = "Some random message string.";
+    static final Throwable e = new Throwable();
+
+    /**
+     * @see AssumptionTest#assumptionsWithMessage()
+     */
+    public static class HasAssumeWithMessage {
+        @Test
+        public void testMethod() {
+            assumeTrue(message, false);
+        }
+    }
+
+    @Test
+    public void assumptionsWithMessage() {
+        final List<Failure> failures =
+                runAndGetAssumptionFailures(HasAssumeWithMessage.class);
+
+        assertTrue(failures.get(0).getMessage().contains(message));
+    }
+
+    /**
+     * @see AssumptionTest#assumptionsWithMessageAndCause()
+     */
+    public static class HasAssumeWithMessageAndCause {
+        @Test
+        public void testMethod() {
+            assumeNoException(message, e);
+        }
+    }
+
+    @Test
+    public void assumptionsWithMessageAndCause() {
+        final List<Failure> failures =
+                runAndGetAssumptionFailures(HasAssumeWithMessageAndCause.class);
+        assertTrue(failures.get(0).getMessage().contains(message));
+        assertSame(failures.get(0).getException().getCause(), e);
+    }
+
+    public static class HasFailingAssumptionWithMessage {
+        @Test
+        public void assumptionsFail() {
+            assumeThat(message, 3, is(4));
+            fail();
+        }
+    }
+
+    @Test
+    public void failedAssumptionsWithMessage() {
+        final List<Failure> failures =
+                runAndGetAssumptionFailures(HasFailingAssumptionWithMessage.class);
+
+        assertEquals(1, failures.size());
+        assertTrue(failures.get(0).getMessage().contains(message));
+    }
+
+    /**
+     * Helper method that runs tests on <code>clazz</code> and returns any
+     * {@link Failure} objects that were {@link AssumptionViolatedException}s.
+     */
+    private static List<Failure> runAndGetAssumptionFailures(Class<?> clazz) {
+        final List<Failure> failures = new ArrayList<Failure>();
+        final JUnitCore core = new JUnitCore();
+        core.addListener(new RunListener() {
+            @Override
+            public void testAssumptionFailure(Failure failure) {
+                failures.add(failure);
+            }
+        });
+        core.run(clazz);
+        return failures;
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/MatcherTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/MatcherTest.java
new file mode 100644
index 0000000..10f13a4
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/MatcherTest.java
@@ -0,0 +1,44 @@
+package org.junit.tests.experimental;
+
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeThat;
+import static org.junit.experimental.results.ResultMatchers.hasFailureContaining;
+import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining;
+
+import java.util.Arrays;
+
+import org.hamcrest.Matcher;
+import org.junit.experimental.results.PrintableResult;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.Description;
+import org.junit.runner.RunWith;
+import org.junit.runner.notification.Failure;
+
+@RunWith(Theories.class)
+public class MatcherTest {
+    @DataPoint
+    public static Matcher<Object> SINGLE_FAILURE = hasSingleFailureContaining("cheese");
+
+    @DataPoint
+    public static Matcher<PrintableResult> ANY_FAILURE = hasFailureContaining("cheese");
+
+    @DataPoint
+    public static PrintableResult TWO_FAILURES_ONE_CHEESE = new PrintableResult(
+            Arrays.asList(failure("cheese"), failure("mustard")));
+
+    @Theory
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public void differentMatchersHaveDifferentDescriptions(
+            Matcher matcher1, Matcher matcher2, Object value) {
+        assumeThat(value, matcher1);
+        assumeThat(value, not(matcher2));
+        assertThat(matcher1.toString(), not(matcher2.toString()));
+    }
+
+    private static Failure failure(String string) {
+        return new Failure(Description.EMPTY, new Error(string));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/AllMaxTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/AllMaxTests.java
new file mode 100644
index 0000000..d78ca36
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/AllMaxTests.java
@@ -0,0 +1,14 @@
+package org.junit.tests.experimental.max;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        DescriptionTest.class,
+        JUnit38SortingTest.class,
+        MaxStarterTest.class
+})
+public class AllMaxTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/DescriptionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/DescriptionTest.java
new file mode 100644
index 0000000..607bb81
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/DescriptionTest.java
@@ -0,0 +1,123 @@
+package org.junit.tests.experimental.max;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import java.lang.annotation.Annotation;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.Description;
+
+public class DescriptionTest {
+
+    @Test
+    public void parseClass_whenCantParse() {
+        assertNull(Description.TEST_MECHANISM.getTestClass());
+    }
+
+    @Test
+    public void parseMethod_whenCantParse() {
+        assertNull(Description.TEST_MECHANISM.getMethodName());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void createSuiteDescription_whenZeroLength() {
+        Description.createSuiteDescription("");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void createSuiteDescription_whenNull() {
+        Description.createSuiteDescription((String) null);
+    }
+
+    @Test
+    public void parseClassAndMethodNoAnnotations() throws Exception {
+        Description description = Description.createTestDescription(Description.class, "aTestMethod");
+
+        assertThat(description.getClassName(), equalTo("org.junit.runner.Description"));
+        assertThat(description.getMethodName(), equalTo("aTestMethod"));
+        assertThat(description.getAnnotations().size(), equalTo(0));
+    }
+
+    @Test
+    public void parseClassAndMethodWithAnnotations() throws Exception {
+        Annotation[] annotations =
+                DescriptionTest.class.getMethod("parseClassAndMethodWithAnnotations").getDeclaredAnnotations();
+
+        Description description = Description.createTestDescription(Description.class, "aTestMethod", annotations);
+
+        assertThat(description.getClassName(), equalTo("org.junit.runner.Description"));
+        assertThat(description.getMethodName(), equalTo("aTestMethod"));
+        assertThat(description.getAnnotations().size(), equalTo(1));
+    }
+
+    @Test
+    public void parseClassNameAndMethodUniqueId() throws Exception {
+        Description description = Description.createTestDescription("not a class name", "aTestMethod", 123);
+
+        assertThat(description.getClassName(), equalTo("not a class name"));
+        assertThat(description.getMethodName(), equalTo("aTestMethod"));
+        assertThat(description.getAnnotations().size(), equalTo(0));
+    }
+
+    @Test
+    public void sameNamesButDifferentUniqueIdAreNotEqual() throws Exception {
+        assertThat(Description.createTestDescription("not a class name", "aTestMethod", 1),
+                not(equalTo(Description.createTestDescription("not a class name", "aTestMethod", 2))));
+    }
+
+    @Test
+    public void usesPassedInClassObject() throws Exception {
+        class URLClassLoader2 extends URLClassLoader {
+            URLClassLoader2(URL... urls) {
+                super(urls);
+            }
+
+            @Override // just making public
+            public Class<?> findClass(String name) throws ClassNotFoundException {
+                return super.findClass(name);
+            }
+        }
+        URL classpath = Sweet.class.getProtectionDomain().getCodeSource().getLocation();
+        URLClassLoader2 loader = new URLClassLoader2(classpath);
+        Class<?> clazz = loader.findClass(Sweet.class.getName());
+        assertEquals(loader, clazz.getClassLoader());
+
+        Description d = Description.createSuiteDescription(clazz);
+        assertEquals(clazz, d.getTestClass());
+        assertNull(d.getMethodName());
+        assertEquals(1, d.getAnnotations().size());
+        assertEquals(Ignore.class, d.getAnnotations().iterator().next().annotationType());
+
+        d = Description.createTestDescription(clazz, "tessed");
+        assertEquals(clazz, d.getTestClass());
+        assertEquals("tessed", d.getMethodName());
+        assertEquals(0, d.getAnnotations().size());
+
+        d = Description.createTestDescription(clazz, "tessed", clazz.getMethod("tessed").getAnnotations());
+        assertEquals(clazz, d.getTestClass());
+        assertEquals("tessed", d.getMethodName());
+        assertEquals(1, d.getAnnotations().size());
+        assertEquals(Test.class, d.getAnnotations().iterator().next().annotationType());
+
+        d = d.childlessCopy();
+        assertEquals(clazz, d.getTestClass());
+        assertEquals("tessed", d.getMethodName());
+        assertEquals(1, d.getAnnotations().size());
+        assertEquals(Test.class, d.getAnnotations().iterator().next().annotationType());
+    }
+
+    @Ignore
+    private static class Sweet {
+        @Test
+        public void tessed() {
+        }
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/JUnit38SortingTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/JUnit38SortingTest.java
new file mode 100644
index 0000000..0d893fb
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/JUnit38SortingTest.java
@@ -0,0 +1,62 @@
+package org.junit.tests.experimental.max;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.util.List;
+
+import junit.framework.TestCase;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.max.MaxCore;
+import org.junit.runner.Description;
+import org.junit.runner.Request;
+
+public class JUnit38SortingTest {
+    private MaxCore fMax;
+    private File fMaxFile;
+
+    @Before
+    public void createMax() {
+        fMaxFile = new File("MaxCore.ser");
+        if (fMaxFile.exists()) {
+            fMaxFile.delete();
+        }
+        fMax = MaxCore.storedLocally(fMaxFile);
+    }
+
+    @After
+    public void forgetMax() {
+        fMaxFile.delete();
+    }
+
+    public static class JUnit4Test {
+        @Test
+        public void pass() {
+        }
+    }
+
+    public static class JUnit38Test extends TestCase {
+        public void testFails() {
+            fail();
+        }
+
+        public void testSucceeds() {
+        }
+
+        public void testSucceedsToo() {
+        }
+    }
+
+    @Test
+    public void preferRecentlyFailed38Test() {
+        Request request = Request.classes(JUnit4Test.class, JUnit38Test.class);
+        fMax.run(request);
+        List<Description> tests = fMax.sortedLeavesForTest(request);
+        Description dontSucceed = Description.createTestDescription(
+                JUnit38Test.class, "testFails");
+        assertEquals(dontSucceed, tests.get(0));
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/MaxStarterTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/MaxStarterTest.java
new file mode 100644
index 0000000..d1bde45
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/max/MaxStarterTest.java
@@ -0,0 +1,292 @@
+package org.junit.tests.experimental.max;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+import junit.framework.TestCase;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.max.MaxCore;
+import org.junit.internal.runners.JUnit38ClassRunner;
+import org.junit.runner.Computer;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+import org.junit.tests.AllTests;
+
+public class MaxStarterTest {
+    private MaxCore fMax;
+
+    private File fMaxFile;
+
+    @Before
+    public void createMax() {
+        fMaxFile = new File("MaxCore.ser");
+        if (fMaxFile.exists()) {
+            fMaxFile.delete();
+        }
+        fMax = MaxCore.storedLocally(fMaxFile);
+    }
+
+    @After
+    public void forgetMax() {
+        fMaxFile.delete();
+    }
+
+    public static class TwoTests {
+        @Test
+        public void succeed() {
+        }
+
+        @Test
+        public void dontSucceed() {
+            fail();
+        }
+    }
+
+    @Test
+    public void twoTestsNotRunComeBackInRandomOrder() {
+        Request request = Request.aClass(TwoTests.class);
+        List<Description> things = fMax.sortedLeavesForTest(request);
+        Description succeed = Description.createTestDescription(TwoTests.class,
+                "succeed");
+        Description dontSucceed = Description.createTestDescription(
+                TwoTests.class, "dontSucceed");
+        assertTrue(things.contains(succeed));
+        assertTrue(things.contains(dontSucceed));
+        assertEquals(2, things.size());
+    }
+
+    @Test
+    public void preferNewTests() {
+        Request one = Request.method(TwoTests.class, "succeed");
+        fMax.run(one);
+        Request two = Request.aClass(TwoTests.class);
+        List<Description> things = fMax.sortedLeavesForTest(two);
+        Description dontSucceed = Description.createTestDescription(
+                TwoTests.class, "dontSucceed");
+        assertEquals(dontSucceed, things.get(0));
+        assertEquals(2, things.size());
+    }
+
+    // This covers a seemingly-unlikely case, where you had a test that failed
+    // on the
+    // last run and you also introduced new tests. In such a case it pretty much
+    // doesn't matter
+    // which order they run, you just want them both to be early in the sequence
+    @Test
+    public void preferNewTestsOverTestsThatFailed() {
+        Request one = Request.method(TwoTests.class, "dontSucceed");
+        fMax.run(one);
+        Request two = Request.aClass(TwoTests.class);
+        List<Description> things = fMax.sortedLeavesForTest(two);
+        Description succeed = Description.createTestDescription(TwoTests.class,
+                "succeed");
+        assertEquals(succeed, things.get(0));
+        assertEquals(2, things.size());
+    }
+
+    @Test
+    public void preferRecentlyFailed() {
+        Request request = Request.aClass(TwoTests.class);
+        fMax.run(request);
+        List<Description> tests = fMax.sortedLeavesForTest(request);
+        Description dontSucceed = Description.createTestDescription(
+                TwoTests.class, "dontSucceed");
+        assertEquals(dontSucceed, tests.get(0));
+    }
+
+    @Test
+    public void sortTestsInMultipleClasses() {
+        Request request = Request.classes(Computer.serial(), TwoTests.class,
+                TwoTests.class);
+        fMax.run(request);
+        List<Description> tests = fMax.sortedLeavesForTest(request);
+        Description dontSucceed = Description.createTestDescription(
+                TwoTests.class, "dontSucceed");
+        assertEquals(dontSucceed, tests.get(0));
+        assertEquals(dontSucceed, tests.get(1));
+    }
+
+    public static class TwoUnEqualTests {
+        @Test
+        public void slow() throws InterruptedException {
+            Thread.sleep(100);
+            fail();
+        }
+
+        @Test
+        public void fast() {
+            fail();
+        }
+
+    }
+
+    @Test
+    public void rememberOldRuns() {
+        fMax.run(TwoUnEqualTests.class);
+
+        MaxCore reincarnation = MaxCore.storedLocally(fMaxFile);
+        List<Failure> failures = reincarnation.run(TwoUnEqualTests.class)
+                .getFailures();
+        assertEquals("fast", failures.get(0).getDescription().getMethodName());
+        assertEquals("slow", failures.get(1).getDescription().getMethodName());
+    }
+
+    @Test
+    public void preferFast() {
+        Request request = Request.aClass(TwoUnEqualTests.class);
+        fMax.run(request);
+        Description thing = fMax.sortedLeavesForTest(request).get(1);
+        assertEquals(Description.createTestDescription(TwoUnEqualTests.class,
+                "slow"), thing);
+    }
+
+    @Test
+    public void listenersAreCalledCorrectlyInTheFaceOfFailures()
+            throws Exception {
+        JUnitCore core = new JUnitCore();
+        final List<Failure> failures = new ArrayList<Failure>();
+        core.addListener(new RunListener() {
+            @Override
+            public void testRunFinished(Result result) throws Exception {
+                failures.addAll(result.getFailures());
+            }
+        });
+        fMax.run(Request.aClass(TwoTests.class), core);
+        assertEquals(1, failures.size());
+    }
+
+    @Test
+    public void testsAreOnlyIncludedOnceWhenExpandingForSorting()
+            throws Exception {
+        Result result = fMax.run(Request.aClass(TwoTests.class));
+        assertEquals(2, result.getRunCount());
+    }
+
+    public static class TwoOldTests extends TestCase {
+        public void testOne() {
+        }
+
+        public void testTwo() {
+        }
+    }
+
+    @Test
+    public void junit3TestsAreRunOnce() throws Exception {
+        Result result = fMax.run(Request.aClass(TwoOldTests.class),
+                new JUnitCore());
+        assertEquals(2, result.getRunCount());
+    }
+
+    @Test
+    public void filterSingleMethodFromOldTestClass() throws Exception {
+        final Description method = Description.createTestDescription(
+                TwoOldTests.class, "testOne");
+        Filter filter = Filter.matchMethodDescription(method);
+        JUnit38ClassRunner child = new JUnit38ClassRunner(TwoOldTests.class);
+        child.filter(filter);
+        assertEquals(1, child.testCount());
+    }
+
+    @Test
+    public void testCountsStandUpToFiltration() {
+        assertFilterLeavesTestUnscathed(AllTests.class);
+    }
+
+    private void assertFilterLeavesTestUnscathed(Class<?> testClass) {
+        Request oneClass = Request.aClass(testClass);
+        Request filtered = oneClass.filterWith(new Filter() {
+            @Override
+            public boolean shouldRun(Description description) {
+                return true;
+            }
+
+            @Override
+            public String describe() {
+                return "Everything";
+            }
+        });
+
+        int filterCount = filtered.getRunner().testCount();
+        int coreCount = oneClass.getRunner().testCount();
+        assertEquals("Counts match up in " + testClass, coreCount, filterCount);
+    }
+
+    private static class MalformedJUnit38Test {
+        private MalformedJUnit38Test() {
+        }
+
+        @SuppressWarnings("unused")
+        public void testSucceeds() {
+        }
+    }
+
+    @Test
+    public void maxShouldSkipMalformedJUnit38Classes() {
+        Request request = Request.aClass(MalformedJUnit38Test.class);
+        fMax.run(request);
+    }
+
+    public static class MalformedJUnit38TestMethod extends TestCase {
+        @SuppressWarnings("unused")
+        private void testNothing() {
+        }
+    }
+
+    @Test
+    public void correctErrorFromMalformedTest() {
+        Request request = Request.aClass(MalformedJUnit38TestMethod.class);
+        JUnitCore core = new JUnitCore();
+        Request sorted = fMax.sortRequest(request);
+        Runner runner = sorted.getRunner();
+        Result result = core.run(runner);
+        Failure failure = result.getFailures().get(0);
+        assertThat(failure.toString(), containsString("MalformedJUnit38TestMethod"));
+        assertThat(failure.toString(), containsString("testNothing"));
+        assertThat(failure.toString(), containsString("isn't public"));
+    }
+
+    public static class HalfMalformedJUnit38TestMethod extends TestCase {
+        public void testSomething() {
+        }
+
+        @SuppressWarnings("unused")
+        private void testNothing() {
+        }
+    }
+
+    @Test
+    public void halfMalformed() {
+        assertThat(JUnitCore.runClasses(HalfMalformedJUnit38TestMethod.class)
+                .getFailureCount(), is(1));
+    }
+
+
+    @Test
+    public void correctErrorFromHalfMalformedTest() {
+        Request request = Request.aClass(HalfMalformedJUnit38TestMethod.class);
+        JUnitCore core = new JUnitCore();
+        Request sorted = fMax.sortRequest(request);
+        Runner runner = sorted.getRunner();
+        Result result = core.run(runner);
+        Failure failure = result.getFailures().get(0);
+        assertThat(failure.toString(), containsString("MalformedJUnit38TestMethod"));
+        assertThat(failure.toString(), containsString("testNothing"));
+        assertThat(failure.toString(), containsString("isn't public"));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/parallel/AllParallelTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/parallel/AllParallelTests.java
new file mode 100644
index 0000000..ef21dd2
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/parallel/AllParallelTests.java
@@ -0,0 +1,13 @@
+package org.junit.tests.experimental.parallel;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        ParallelClassTest.class,
+        ParallelMethodTest.class
+})
+public class AllParallelTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/parallel/ParallelClassTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/parallel/ParallelClassTest.java
new file mode 100644
index 0000000..86a2646
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/parallel/ParallelClassTest.java
@@ -0,0 +1,79 @@
+package org.junit.tests.experimental.parallel;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNot.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.ParallelComputer;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+
+public class ParallelClassTest {
+    private static final long TIMEOUT = 15;
+    private static volatile Thread fExample1One = null;
+    private static volatile Thread fExample1Two = null;
+    private static volatile Thread fExample2One = null;
+    private static volatile Thread fExample2Two = null;
+    private static volatile CountDownLatch fSynchronizer;
+
+    public static class Example1 {
+        @Test
+        public void one() throws InterruptedException {
+            fSynchronizer.countDown();
+            assertTrue(fSynchronizer.await(TIMEOUT, TimeUnit.SECONDS));
+            fExample1One = Thread.currentThread();
+        }
+
+        @Test
+        public void two() throws InterruptedException {
+            fSynchronizer.countDown();
+            assertTrue(fSynchronizer.await(TIMEOUT, TimeUnit.SECONDS));
+            fExample1Two = Thread.currentThread();
+        }
+    }
+
+    public static class Example2 {
+        @Test
+        public void one() throws InterruptedException {
+            fSynchronizer.countDown();
+            assertTrue(fSynchronizer.await(TIMEOUT, TimeUnit.SECONDS));
+            fExample2One = Thread.currentThread();
+        }
+
+        @Test
+        public void two() throws InterruptedException {
+            fSynchronizer.countDown();
+            assertTrue(fSynchronizer.await(TIMEOUT, TimeUnit.SECONDS));
+            fExample2Two = Thread.currentThread();
+        }
+    }
+
+    @Before
+    public void init() {
+        fExample1One = null;
+        fExample1Two = null;
+        fExample2One = null;
+        fExample2Two = null;
+        fSynchronizer = new CountDownLatch(2);
+    }
+
+    @Test
+    public void testsRunInParallel() {
+        Result result = JUnitCore.runClasses(ParallelComputer.classes(), Example1.class, Example2.class);
+        assertTrue(result.wasSuccessful());
+        assertNotNull(fExample1One);
+        assertNotNull(fExample1Two);
+        assertNotNull(fExample2One);
+        assertNotNull(fExample2Two);
+        assertThat(fExample1One, is(fExample1Two));
+        assertThat(fExample2One, is(fExample2Two));
+        assertThat(fExample1One, is(not(fExample2One)));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/parallel/ParallelMethodTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/parallel/ParallelMethodTest.java
new file mode 100644
index 0000000..fd4b4de
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/parallel/ParallelMethodTest.java
@@ -0,0 +1,61 @@
+package org.junit.tests.experimental.parallel;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNot.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.ParallelComputer;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+
+public class ParallelMethodTest {
+    private static final long TIMEOUT = 15;
+    private static volatile Thread fOne = null;
+    private static volatile Thread fTwo = null;
+
+    public static class Example {
+        private static volatile CountDownLatch fSynchronizer;
+
+        @BeforeClass
+        public static void init() {
+            fSynchronizer = new CountDownLatch(2);
+        }
+
+        @Test
+        public void one() throws InterruptedException {
+            fSynchronizer.countDown();
+            assertTrue(fSynchronizer.await(TIMEOUT, TimeUnit.SECONDS));
+            fOne = Thread.currentThread();
+        }
+
+        @Test
+        public void two() throws InterruptedException {
+            fSynchronizer.countDown();
+            assertTrue(fSynchronizer.await(TIMEOUT, TimeUnit.SECONDS));
+            fTwo = Thread.currentThread();
+        }
+    }
+
+    @Before
+    public void init() {
+        fOne = null;
+        fTwo = null;
+    }
+
+    @Test
+    public void testsRunInParallel() {
+        Result result = JUnitCore.runClasses(ParallelComputer.methods(), Example.class);
+        assertTrue(result.wasSuccessful());
+        assertNotNull(fOne);
+        assertNotNull(fTwo);
+        assertThat(fOne, is(not(fTwo)));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/results/AllResultsTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/results/AllResultsTests.java
new file mode 100644
index 0000000..f197569
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/results/AllResultsTests.java
@@ -0,0 +1,13 @@
+package org.junit.tests.experimental.results;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        PrintableResultTest.class,
+        ResultMatchersTest.class
+})
+public class AllResultsTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/results/PrintableResultTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/results/PrintableResultTest.java
new file mode 100644
index 0000000..3a6e366
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/results/PrintableResultTest.java
@@ -0,0 +1,50 @@
+package org.junit.tests.experimental.results;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+
+import org.junit.experimental.results.PrintableResult;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.Description;
+import org.junit.runner.RunWith;
+import org.junit.runner.notification.Failure;
+
+@RunWith(Theories.class)
+public class PrintableResultTest {
+    @Theory(nullsAccepted = false)
+    public void backTraceHasGoodToString(String descriptionName,
+            final String stackTraceClassName) {
+        Failure failure = new Failure(Description
+                .createSuiteDescription(descriptionName), new Throwable() {
+            private static final long serialVersionUID = 1L;
+
+            @Override
+            public StackTraceElement[] getStackTrace() {
+                return new StackTraceElement[]{new StackTraceElement(
+                        stackTraceClassName, "methodName", "fileName", 1)};
+            }
+        });
+
+        assertThat(new PrintableResult(asList(failure)).toString(), allOf(
+                containsString(descriptionName), containsString(stackTraceClassName)));
+    }
+
+    @DataPoint
+    public static String SHELL_POINT = "Shell Point";
+
+    @Theory
+    public void includeMultipleFailures(String secondExceptionName) {
+        PrintableResult backtrace = new PrintableResult(Arrays.asList(
+                new Failure(Description.createSuiteDescription("firstName"),
+                        new RuntimeException("firstException")), new Failure(
+                Description.createSuiteDescription("secondName"),
+                new RuntimeException(secondExceptionName))));
+        assertThat(backtrace.toString(), containsString(secondExceptionName));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/results/ResultMatchersTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/results/ResultMatchersTest.java
new file mode 100644
index 0000000..768bfba
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/results/ResultMatchersTest.java
@@ -0,0 +1,46 @@
+package org.junit.tests.experimental.results;
+
+import org.junit.Test;
+import org.junit.experimental.results.PrintableResult;
+import org.junit.experimental.results.ResultMatchers;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.Description;
+import org.junit.runner.notification.Failure;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class ResultMatchersTest {
+
+    @Test
+    public void hasFailuresHasGoodDescription() {
+        assertThat(ResultMatchers.failureCountIs(3).toString(),
+                is("has 3 failures"));
+    }
+
+    @Theory
+    public void hasFailuresDescriptionReflectsInput(int i) {
+        assertThat(ResultMatchers.failureCountIs(i).toString(),
+                containsString("" + i));
+    }
+
+    @Test
+    public void hasFailureContaining_givenResultWithNoFailures() {
+        PrintableResult resultWithNoFailures = new PrintableResult(new ArrayList<Failure>());
+
+        assertThat(ResultMatchers.hasFailureContaining("").matches(resultWithNoFailures), is(false));
+    }
+
+    @Test
+    public void hasFailureContaining_givenResultWithOneFailure() {
+        PrintableResult resultWithOneFailure = new PrintableResult(Collections.singletonList(
+                new Failure(Description.EMPTY, new RuntimeException("my failure"))));
+
+        assertThat(ResultMatchers.hasFailureContaining("my failure").matches(resultWithOneFailure), is(true));
+        assertThat(ResultMatchers.hasFailureContaining("his failure").matches(resultWithOneFailure), is(false));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/AllTheoriesTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/AllTheoriesTests.java
new file mode 100644
index 0000000..41d653b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/AllTheoriesTests.java
@@ -0,0 +1,19 @@
+package org.junit.tests.experimental.theories;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+import org.junit.tests.experimental.theories.internal.AllTheoriesInternalTests;
+import org.junit.tests.experimental.theories.runner.AllTheoriesRunnerTests;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AllTheoriesInternalTests.class,
+        AllTheoriesRunnerTests.class,
+        ParameterSignatureTest.class,
+        TestedOnSupplierTest.class,
+        AssumingInTheoriesTest.class,
+        PotentialAssignmentTest.class
+})
+public class AllTheoriesTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/AssumingInTheoriesTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/AssumingInTheoriesTest.java
new file mode 100644
index 0000000..099b50f
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/AssumingInTheoriesTest.java
@@ -0,0 +1,42 @@
+package org.junit.tests.experimental.theories;
+
+import static org.junit.tests.experimental.theories.TheoryTestUtils.runTheoryClass;
+import org.junit.Assert;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runners.model.InitializationError;
+
+@RunWith(Theories.class)
+public class AssumingInTheoriesTest {
+
+    @Test
+    public void noTheoryAnnotationMeansAssumeShouldIgnore() {
+        Assume.assumeTrue(false);
+    }
+
+    @Test
+    public void theoryMeansOnlyAssumeShouldFail() throws InitializationError {
+        Result result = runTheoryClass(TheoryWithNoUnassumedParameters.class);
+        Assert.assertEquals(1, result.getFailureCount());
+    }
+
+    /**
+     * Simple class that SHOULD fail because no parameters are met.
+     */
+    public static class TheoryWithNoUnassumedParameters {
+
+        @DataPoint
+        public static final boolean FALSE = false;
+
+        @Theory
+        public void theoryWithNoUnassumedParameters(boolean value) {
+            Assume.assumeTrue(value);
+        }
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/ParameterSignatureTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/ParameterSignatureTest.java
new file mode 100644
index 0000000..cf786ba
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/ParameterSignatureTest.java
@@ -0,0 +1,92 @@
+package org.junit.tests.experimental.theories;
+
+import static org.hamcrest.CoreMatchers.isA;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.List;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.experimental.theories.suppliers.TestedOn;
+import org.junit.runner.RunWith;
+
+@RunWith(Theories.class)
+public class ParameterSignatureTest {
+    @DataPoint
+    public static Method getType() throws SecurityException,
+            NoSuchMethodException {
+        return ParameterSignatureTest.class.getMethod("getType", Method.class,
+                int.class);
+    }
+
+    @DataPoint
+    public static int ZERO = 0;
+
+    @DataPoint
+    public static int ONE = 1;
+
+    @Theory
+    public void getType(Method method, int index) {
+        assumeTrue(index < method.getParameterTypes().length);
+        assertEquals(method.getParameterTypes()[index], ParameterSignature
+                .signatures(method).get(index).getType());
+    }
+
+    public void foo(@TestedOn(ints = {1, 2, 3}) int x) {
+    }
+
+    @Test
+    public void getAnnotations() throws SecurityException,
+            NoSuchMethodException {
+        Method method = getClass().getMethod("foo", int.class);
+        List<Annotation> annotations = ParameterSignature.signatures(method)
+                .get(0).getAnnotations();
+        assertThat(annotations,
+                CoreMatchers.<TestedOn>hasItem(isA(TestedOn.class)));
+    }
+    
+    public void intMethod(int param) {
+    }
+    
+    public void integerMethod(Integer param) {
+    }
+    
+    public void numberMethod(Number param) {
+    }
+
+    @Test
+    public void primitiveTypesShouldBeAcceptedAsWrapperTypes() throws Exception {
+        List<ParameterSignature> signatures = ParameterSignature
+                .signatures(getClass().getMethod("integerMethod", Integer.class));
+        ParameterSignature integerSignature = signatures.get(0);
+
+        assertTrue(integerSignature.canAcceptType(int.class));
+    }
+    
+    @Test
+    public void primitiveTypesShouldBeAcceptedAsWrapperTypeAssignables() throws Exception {
+        List<ParameterSignature> signatures = ParameterSignature
+                .signatures(getClass().getMethod("numberMethod", Number.class));
+        ParameterSignature numberSignature = signatures.get(0);
+
+        assertTrue(numberSignature.canAcceptType(int.class));
+    }
+    
+    @Test
+    public void wrapperTypesShouldBeAcceptedAsPrimitiveTypes() throws Exception {
+        List<ParameterSignature> signatures = ParameterSignature
+                .signatures(getClass().getMethod("intMethod", int.class));
+        ParameterSignature intSignature = signatures.get(0);
+
+        assertTrue(intSignature.canAcceptType(Integer.class));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/PotentialAssignmentTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/PotentialAssignmentTest.java
new file mode 100644
index 0000000..45071ed
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/PotentialAssignmentTest.java
@@ -0,0 +1,57 @@
+package org.junit.tests.experimental.theories;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import org.junit.experimental.theories.PotentialAssignment;
+import org.junit.experimental.theories.PotentialAssignment.CouldNotGenerateValueException;
+
+public class PotentialAssignmentTest {
+
+    @Test
+    public void shouldUseQuotedValueInDescription() throws CouldNotGenerateValueException {
+        String name = "stringDatapoint";
+        Object value = new Object() {
+            @Override
+            public String toString() {
+                return "string value";
+            }
+        };
+
+        PotentialAssignment assignment = PotentialAssignment.forValue(name, value);
+
+        assertEquals("\"string value\" <from stringDatapoint>", assignment.getDescription());
+    }
+
+    @Test
+    public void shouldNotUseQuotesForNullValueDescriptions() throws CouldNotGenerateValueException {
+        String name = "nullDatapoint";
+        Object value = null;
+
+        PotentialAssignment assignment = PotentialAssignment.forValue(name, value);
+
+        assertEquals("null <from nullDatapoint>", assignment.getDescription());
+    }
+
+    @Test
+    public void shouldIncludeFailureInDescriptionIfToStringFails() throws CouldNotGenerateValueException {
+        String name = "explodingValue";
+        Object value = new Object() {
+            @Override
+            public String toString() {
+                throw new RuntimeException("Oh no!");
+            }
+        };
+
+        PotentialAssignment assignment = PotentialAssignment.forValue(name, value);
+
+        assertEquals("[toString() threw RuntimeException: Oh no!] <from explodingValue>", assignment.getDescription());
+    }
+
+    @Test
+    public void shouldReturnGivenValue() throws CouldNotGenerateValueException {
+        Object value = new Object();
+        PotentialAssignment assignment = PotentialAssignment.forValue("name", value);
+        assertEquals(value, assignment.getValue());
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/TestedOnSupplierTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/TestedOnSupplierTest.java
new file mode 100644
index 0000000..1376171
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/TestedOnSupplierTest.java
@@ -0,0 +1,32 @@
+package org.junit.tests.experimental.theories;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.experimental.theories.PotentialAssignment;
+import org.junit.experimental.theories.suppliers.TestedOn;
+import org.junit.experimental.theories.suppliers.TestedOnSupplier;
+
+public class TestedOnSupplierTest {
+
+    public void foo(@TestedOn(ints = {1}) int x) {
+    }
+
+    @Test
+    public void descriptionStatesParameterName() throws Exception {
+        TestedOnSupplier supplier = new TestedOnSupplier();
+        List<PotentialAssignment> assignments = supplier.getValueSources(signatureOfFoo());
+        assertThat(assignments.get(0).getDescription(), is("\"1\" <from ints>"));
+    }
+
+    private ParameterSignature signatureOfFoo() throws NoSuchMethodException {
+        Method method = getClass().getMethod("foo", int.class);
+        return ParameterSignature.signatures(method).get(0);
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/TheoryTestUtils.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/TheoryTestUtils.java
new file mode 100644
index 0000000..6e1b351
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/TheoryTestUtils.java
@@ -0,0 +1,33 @@
+package org.junit.tests.experimental.theories;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+import org.junit.experimental.theories.PotentialAssignment;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.internal.Assignments;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.Runner;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.TestClass;
+
+public final class TheoryTestUtils {
+    
+    private TheoryTestUtils() { }
+    
+    public static List<PotentialAssignment> potentialAssignments(Method method)
+            throws Throwable {
+        return Assignments.allUnassigned(method,
+                new TestClass(method.getDeclaringClass()))
+                .potentialsForNextUnassigned();
+    }
+    
+    public static Result runTheoryClass(Class<?> testClass) throws InitializationError {
+        Runner theoryRunner = new Theories(testClass);
+        Request request = Request.runner(theoryRunner);
+        return new JUnitCore().run(request);
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/Correspondent.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/Correspondent.java
new file mode 100644
index 0000000..81297b5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/Correspondent.java
@@ -0,0 +1,7 @@
+package org.junit.tests.experimental.theories.extendingwithstubs;
+
+public interface Correspondent {
+
+    String getAnswer(String question, String... bucket);
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/Guesser.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/Guesser.java
new file mode 100644
index 0000000..e57a3b3
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/Guesser.java
@@ -0,0 +1,126 @@
+package org.junit.tests.experimental.theories.extendingwithstubs;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Random;
+
+import org.hamcrest.BaseDescription;
+import org.hamcrest.Description;
+import org.junit.internal.AssumptionViolatedException;
+
+public class Guesser<T> extends ReguessableValue {
+    static class GuessMap extends HashMap<MethodCall, Object> implements
+            InvocationHandler {
+        private static final long serialVersionUID = 1L;
+
+        public GuessMap(GuessMap guesses) {
+            super(guesses);
+        }
+
+        public GuessMap() {
+        }
+
+        GuessMap replaceGuess(Object oldValue, Object newValue) {
+            GuessMap newGuesses = new GuessMap(this);
+            for (Entry<MethodCall, Object> entry : newGuesses.entrySet()) {
+                if (entry.getValue().equals(oldValue)) {
+                    entry.setValue(newValue);
+                }
+            }
+            return newGuesses;
+        }
+
+        protected Object generateGuess(Class<?> returnType) {
+            if (returnType.equals(String.class)) {
+                return "GUESS" + new Random().nextInt();
+            }
+            if (returnType.equals(Integer.class)
+                    || returnType.equals(int.class)) {
+                return new Random().nextInt();
+            }
+            return null;
+        }
+
+        Object getGuess(MethodCall call) {
+            if (!containsKey(call)) {
+                put(call, generateGuess(call.getReturnType()));
+            }
+            return get(call);
+        }
+
+        public Object invoke(Object proxy, Method method, Object[] args)
+                throws Throwable {
+            return getGuess(new MethodCall(method, args));
+        }
+    }
+
+    private final GuessMap guesses;
+
+    private final Class<? extends T> type;
+
+    public Guesser(Class<? extends T> type) {
+        this(type, new GuessMap());
+    }
+
+    public Guesser(Class<? extends T> type2, GuessMap guesses) {
+        this.type = type2;
+        this.guesses = guesses;
+    }
+
+    @SuppressWarnings("unchecked")
+    public T getProxy() {
+        return (T) Proxy.newProxyInstance(getClass().getClassLoader(),
+                new Class[]{getType()}, guesses);
+    }
+
+    @Override
+    public List<ReguessableValue> reguesses(AssumptionViolatedException e) {
+        final ArrayList<ReguessableValue> returnThis = new ArrayList<ReguessableValue>();
+        e.describeTo(new BaseDescription() {
+            @Override
+            protected void append(char arg0) {
+            }
+
+            boolean expectedSeen = false;
+            Object expected = null;
+
+            @Override
+            public Description appendValue(Object value) {
+                noteValue(value);
+                return super.appendValue(value);
+            }
+
+            private void noteValue(Object value) {
+                if (!expectedSeen) {
+                    expected = value;
+                    expectedSeen = true;
+                    return;
+                }
+
+                GuessMap newGuesses = guesses.replaceGuess(expected, value);
+                returnThis.add(new Guesser<T>(getType(), newGuesses));
+            }
+        });
+        return returnThis;
+    }
+
+    @Override
+    public Object getValue() throws CouldNotGenerateValueException {
+        return getProxy();
+    }
+
+    public Class<? extends T> getType() {
+        return type;
+    }
+
+    @Override
+    public String getDescription() throws CouldNotGenerateValueException {
+        return "guesser[" + type + "]";
+    }
+
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/GuesserQueue.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/GuesserQueue.java
new file mode 100644
index 0000000..2722631
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/GuesserQueue.java
@@ -0,0 +1,58 @@
+package org.junit.tests.experimental.theories.extendingwithstubs;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.experimental.theories.PotentialAssignment;
+import org.junit.internal.AssumptionViolatedException;
+
+public class GuesserQueue extends ArrayList<ReguessableValue> {
+    static class ReguessableDecorator extends ReguessableValue {
+        private final PotentialAssignment delegate;
+
+        public ReguessableDecorator(PotentialAssignment delegate) {
+            this.delegate = delegate;
+        }
+
+        @Override
+        public List<ReguessableValue> reguesses(AssumptionViolatedException e) {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public Object getValue() throws CouldNotGenerateValueException {
+            return delegate.getValue();
+        }
+
+        @Override
+        public String getDescription() throws CouldNotGenerateValueException {
+            return delegate.getDescription();
+        }
+    }
+
+    static GuesserQueue forSingleValues(
+            List<PotentialAssignment> potentials) {
+        GuesserQueue returnThis = new GuesserQueue();
+        for (PotentialAssignment potentialParameterValue : potentials) {
+            returnThis
+                    .add(new GuesserQueue.ReguessableDecorator(potentialParameterValue));
+        }
+        return returnThis;
+    }
+
+    private static final long serialVersionUID = 1L;
+    private ReguessableValue lastRemoved;
+
+    public void update(AssumptionViolatedException e) {
+        if (lastRemoved != null) {
+            addAll(lastRemoved.reguesses(e));
+        }
+    }
+
+    @Override
+    public ReguessableValue remove(int index) {
+        lastRemoved = super.remove(index);
+        return lastRemoved;
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/MethodCall.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/MethodCall.java
new file mode 100644
index 0000000..b79ac2b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/MethodCall.java
@@ -0,0 +1,55 @@
+package org.junit.tests.experimental.theories.extendingwithstubs;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class MethodCall {
+    private final Method method;
+    private final Object[] args;
+
+    public MethodCall(Method method, Object... args) {
+        this.method = method;
+        this.args = args;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        MethodCall call = (MethodCall) obj;
+        return call.method.equals(method) && Arrays.deepEquals(call.args, args);
+    }
+
+    @Override
+    public int hashCode() {
+        return 1;
+    }
+
+    public Class<?> getReturnType() {
+        return method.getReturnType();
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s(%s)", method.getName(), argListString());
+    }
+
+    private String argListString() {
+        if (args == null) {
+            return null;
+        }
+        return argList().toString().substring(1, argList().toString().length() - 1);
+    }
+
+    private List<Object> argList() {
+        ArrayList<Object> list = new ArrayList<Object>();
+        for (Object arg : args) {
+            list.add(new StringableObject(arg));
+        }
+        return list;
+    }
+
+    public Object stringableObject(Object arg) {
+        return new StringableObject(arg).stringableObject();
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/ReguessableValue.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/ReguessableValue.java
new file mode 100644
index 0000000..6c1fe75
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/ReguessableValue.java
@@ -0,0 +1,16 @@
+package org.junit.tests.experimental.theories.extendingwithstubs;
+
+import java.util.List;
+
+import org.junit.experimental.theories.PotentialAssignment;
+import org.junit.internal.AssumptionViolatedException;
+
+public abstract class ReguessableValue extends PotentialAssignment {
+
+    public ReguessableValue() {
+        super();
+    }
+
+    public abstract List<ReguessableValue> reguesses(
+            AssumptionViolatedException e);
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/StringableObject.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/StringableObject.java
new file mode 100644
index 0000000..de3ce98
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/StringableObject.java
@@ -0,0 +1,29 @@
+package org.junit.tests.experimental.theories.extendingwithstubs;
+
+import java.util.Arrays;
+
+public class StringableObject {
+    public Object obj;
+
+    public StringableObject(Object obj) {
+        this.obj = obj;
+    }
+
+    public Object stringableObject() {
+        if (isListableArray()) {
+            return Arrays.asList((Object[]) obj);
+        } else {
+            return obj;
+        }
+    }
+
+    private boolean isListableArray() {
+        Class<?> type = obj.getClass();
+        return type.isArray() && !type.getComponentType().isPrimitive();
+    }
+
+    @Override
+    public String toString() {
+        return stringableObject().toString();
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/Stub.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/Stub.java
new file mode 100644
index 0000000..aa320d5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/Stub.java
@@ -0,0 +1,8 @@
+package org.junit.tests.experimental.theories.extendingwithstubs;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Stub {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/StubbedTheories.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/StubbedTheories.java
new file mode 100644
index 0000000..cf6a6ef
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/StubbedTheories.java
@@ -0,0 +1,65 @@
+package org.junit.tests.experimental.theories.extendingwithstubs;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.internal.Assignments;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+import org.junit.runners.model.TestClass;
+
+public class StubbedTheories extends Theories {
+    public StubbedTheories(Class<?> klass) throws InitializationError {
+        super(klass);
+    }
+
+    @Override
+    public Statement methodBlock(FrameworkMethod method) {
+        return new StubbedTheoryAnchor(method, getTestClass());
+    }
+
+    public static class StubbedTheoryAnchor extends TheoryAnchor {
+        public StubbedTheoryAnchor(FrameworkMethod method, TestClass testClass) {
+            super(method, testClass);
+        }
+
+        private List<GuesserQueue> queues = new ArrayList<GuesserQueue>();
+
+        @Override
+        protected void handleAssumptionViolation(AssumptionViolatedException e) {
+            super.handleAssumptionViolation(e);
+            for (GuesserQueue queue : queues) {
+                queue.update(e);
+            }
+        }
+
+        @Override
+        protected void runWithIncompleteAssignment(Assignments incomplete)
+                throws Throwable {
+            GuesserQueue guessers = createGuesserQueue(incomplete);
+            queues.add(guessers);
+            while (!guessers.isEmpty())
+                runWithAssignment(incomplete.assignNext(guessers.remove(0)));
+            queues.remove(guessers);
+        }
+
+        private GuesserQueue createGuesserQueue(Assignments incomplete)
+                throws Throwable {
+            ParameterSignature nextUnassigned = incomplete.nextUnassigned();
+
+            if (nextUnassigned.hasAnnotation(Stub.class)) {
+                GuesserQueue queue = new GuesserQueue();
+                queue.add(new Guesser<Object>(nextUnassigned.getType()));
+                return queue;
+            }
+
+            return GuesserQueue.forSingleValues(incomplete.potentialsForNextUnassigned());
+        }
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/StubbedTheoriesTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/StubbedTheoriesTest.java
new file mode 100644
index 0000000..a86bcd6
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/extendingwithstubs/StubbedTheoriesTest.java
@@ -0,0 +1,16 @@
+package org.junit.tests.experimental.theories.extendingwithstubs;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assume.assumeThat;
+
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+
+@RunWith(StubbedTheories.class)
+public class StubbedTheoriesTest {
+    @Theory
+    public void ask(@Stub Correspondent correspondent) {
+        assumeThat(correspondent.getAnswer("What is five?", "four", "five"),
+                is("five"));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/AllMembersSupplierTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/AllMembersSupplierTest.java
new file mode 100644
index 0000000..64e77b1
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/AllMembersSupplierTest.java
@@ -0,0 +1,209 @@
+package org.junit.tests.experimental.theories.internal;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.tests.experimental.theories.TheoryTestUtils.potentialAssignments;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.experimental.theories.PotentialAssignment;
+import org.junit.experimental.theories.Theory;
+import org.junit.experimental.theories.internal.AllMembersSupplier;
+import org.junit.rules.ExpectedException;
+import org.junit.runners.model.TestClass;
+
+public class AllMembersSupplierTest {
+    @Rule
+    public ExpectedException expected = ExpectedException.none();
+    
+    public static class HasDataPointsArrayField {
+        @DataPoints
+        public static String[] list = new String[] { "qwe", "asd" };
+
+        @Theory
+        public void theory(String param) {
+        }
+    }
+    
+    @Test
+    public void dataPointsArrayShouldBeRecognized() throws Throwable {
+        List<PotentialAssignment> assignments = potentialAssignments(
+                HasDataPointsArrayField.class.getMethod("theory", String.class));
+        
+        assertEquals(2, assignments.size());
+    }
+    
+    public static class HasDataPointsArrayWithMatchingButInaccurateTypes {
+        @DataPoints
+        public static Object[] objects = {1, "string!", 2};
+
+        @Theory
+        public void theory(Integer param) {
+        }
+    }
+
+    @Test
+    public void dataPointsArrayShouldBeRecognizedOnValueTypeNotFieldType() throws Throwable {
+        List<PotentialAssignment> assignments = potentialAssignments(
+                HasDataPointsArrayWithMatchingButInaccurateTypes.class.getMethod("theory", Integer.class));
+        
+        assertEquals(2, assignments.size());
+    }
+    
+    public static class HasDataPointMethodWithOverlyGeneralTypes {
+        @DataPoint
+        public static Integer object() {
+            return 1;
+        }
+
+        @Theory
+        public void theory(Object param) {
+        }
+    }
+
+    @Test
+    public void dataPointMethodShouldBeRecognizedForOverlyGeneralParameters() throws Throwable {
+        List<PotentialAssignment> assignments = potentialAssignments(
+                HasDataPointMethodWithOverlyGeneralTypes.class.getMethod("theory", Object.class));
+        
+        assertEquals(1, assignments.size());
+    }
+    
+    public static class HasDataPointsWithObjectParameter {
+        @DataPoints
+        public static Object[] objectField = {1, 2};
+
+        @Theory
+        public void theory(Object obj) {
+        }
+    }
+
+    @Test
+    public void dataPointsAnnotationMeansTreatAsArrayOnly() throws Throwable {
+        List<PotentialAssignment> assignments = potentialAssignments(
+                HasDataPointsWithObjectParameter.class.getMethod("theory", Object.class));
+        
+        assertEquals(2, assignments.size());
+        for (PotentialAssignment assignment : assignments) {
+            assertNotEquals(HasDataPointsWithObjectParameter.objectField, assignment.getValue());
+        }
+    }
+
+    public static class HasDataPointsFieldWithNullValue {
+        @DataPoints
+        public static Object[] objects = {null, "a"};
+
+        public HasDataPointsFieldWithNullValue(Object obj) {
+        }
+    }
+
+    @Test
+    public void dataPointsArrayFieldMayContainNullValue() throws Throwable {
+        List<PotentialAssignment> valueSources = allMemberValuesFor(
+                HasDataPointsFieldWithNullValue.class, Object.class);
+        assertThat(valueSources.size(), is(2));
+    }
+
+    public static class HasDataPointsMethodWithNullValue {
+        @DataPoints
+        public static Integer[] getObjects() {
+            return new Integer[] {null, 1};
+        }
+
+        public HasDataPointsMethodWithNullValue(Integer i) {
+        }
+    }
+
+    @Test
+    public void dataPointsArrayMethodMayContainNullValue() throws Throwable {
+        List<PotentialAssignment> valueSources = allMemberValuesFor(
+                HasDataPointsMethodWithNullValue.class, Integer.class);
+        assertThat(valueSources.size(), is(2));
+    }
+    
+    public static class HasFailingDataPointsArrayMethod {
+        @DataPoints
+        public static Object[] objects() {
+            throw new RuntimeException("failing method");
+        }
+
+        public HasFailingDataPointsArrayMethod(Object obj) {
+        }
+    }
+
+    @Test
+    public void allMembersFailsOnFailingDataPointsArrayMethod() throws Throwable {
+        expected.expect(RuntimeException.class);
+        expected.expectMessage("failing method");
+        allMemberValuesFor(HasFailingDataPointsArrayMethod.class, Object.class);
+    }
+
+    private List<PotentialAssignment> allMemberValuesFor(Class<?> testClass,
+            Class<?>... constructorParameterTypes) throws Throwable {
+        return new AllMembersSupplier(new TestClass(testClass))
+                .getValueSources(ParameterSignature.signatures(
+                        testClass.getConstructor(constructorParameterTypes))
+                        .get(0));
+    }
+    
+    public static class HasDataPointsListField {
+        @DataPoints
+        public static List<String> list = Arrays.asList("one", "two");
+
+        @Theory
+        public void theory(String param) {
+        }
+    }
+
+    @Test
+    public void dataPointsCollectionFieldsShouldBeRecognized() throws Throwable {
+        List<PotentialAssignment> assignments = potentialAssignments(
+            HasDataPointsListField.class.getMethod("theory", String.class));
+
+        assertEquals(2, assignments.size());
+    }
+    
+    public static class HasDataPointsListMethod {
+        @DataPoints
+        public static List<String> getList() {
+            return Arrays.asList("one", "two");
+        }
+
+        @Theory
+        public void theory(String param) {
+        }
+    }
+
+    @Test
+    public void dataPointsCollectionMethodShouldBeRecognized() throws Throwable {
+        List<PotentialAssignment> assignments = potentialAssignments(
+            HasDataPointsListMethod.class.getMethod("theory", String.class));
+
+        assertEquals(2, assignments.size());
+    }
+    
+    public static class HasDataPointsListFieldWithOverlyGenericTypes {
+        @DataPoints
+        public static List<Object> list = Arrays.asList("string", new Object());
+
+        @Theory
+        public void theory(String param) {
+        }
+    }
+
+    @Test
+    public void dataPointsCollectionShouldBeRecognizedIgnoringStrangeTypes() throws Throwable {
+        List<PotentialAssignment> assignments = potentialAssignments(
+            HasDataPointsListFieldWithOverlyGenericTypes.class.getMethod("theory", String.class));
+
+        assertEquals(1, assignments.size());
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/AllTheoriesInternalTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/AllTheoriesInternalTests.java
new file mode 100644
index 0000000..7c87afa
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/AllTheoriesInternalTests.java
@@ -0,0 +1,14 @@
+package org.junit.tests.experimental.theories.internal;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AllMembersSupplierTest.class,
+        ParameterizedAssertionErrorTest.class,
+        SpecificDataPointsSupplierTest.class
+})
+public class AllTheoriesInternalTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/ParameterizedAssertionErrorTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/ParameterizedAssertionErrorTest.java
new file mode 100644
index 0000000..285ebf5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/ParameterizedAssertionErrorTest.java
@@ -0,0 +1,95 @@
+package org.junit.tests.experimental.theories.internal;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assume.assumeThat;
+
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.experimental.theories.internal.ParameterizedAssertionError;
+import org.junit.runner.RunWith;
+
+@RunWith(Theories.class)
+public class ParameterizedAssertionErrorTest {
+    @DataPoint
+    public static final String METHOD_NAME = "methodName";
+
+    @DataPoint
+    public static final NullPointerException NULL_POINTER_EXCEPTION = new NullPointerException();
+
+    @DataPoint
+    public static Object[] NO_OBJECTS = new Object[0];
+
+    @DataPoint
+    public static ParameterizedAssertionError A = new ParameterizedAssertionError(
+            NULL_POINTER_EXCEPTION, METHOD_NAME);
+
+    @DataPoint
+    public static ParameterizedAssertionError B = new ParameterizedAssertionError(
+            NULL_POINTER_EXCEPTION, METHOD_NAME);
+
+    @DataPoint
+    public static ParameterizedAssertionError B2 = new ParameterizedAssertionError(
+            NULL_POINTER_EXCEPTION, "methodName2");
+
+    @Theory
+    public void equalParameterizedAssertionErrorsHaveSameToString(
+            ParameterizedAssertionError a, ParameterizedAssertionError b) {
+        assumeThat(a, is(b));
+        assertThat(a.toString(), is(b.toString()));
+    }
+
+    @Theory
+    public void differentParameterizedAssertionErrorsHaveDifferentToStrings(
+            ParameterizedAssertionError a, ParameterizedAssertionError b) {
+        assumeThat(a, not(b));
+        assertThat(a.toString(), not(b.toString()));
+    }
+
+    @Theory
+    public void equalsReturnsTrue(Throwable targetException, String methodName,
+            Object[] params) {
+        assertThat(
+                new ParameterizedAssertionError(targetException, methodName, params),
+                is(new ParameterizedAssertionError(targetException, methodName, params)));
+    }
+
+    @Theory
+    public void sameHashCodeWhenEquals(Throwable targetException, String methodName,
+            Object[] params) {
+        ParameterizedAssertionError one = new ParameterizedAssertionError(
+                targetException, methodName, params);
+        ParameterizedAssertionError two = new ParameterizedAssertionError(
+                targetException, methodName, params);
+        assumeThat(one, is(two));
+
+        assertThat(one.hashCode(), is(two.hashCode()));
+    }
+
+    @Theory(nullsAccepted = false)
+    public void buildParameterizedAssertionError(String methodName, String param) {
+        assertThat(new ParameterizedAssertionError(
+                new RuntimeException(), methodName, param).toString(),
+                containsString(methodName));
+    }
+
+    @Theory
+    public void isNotEqualToNull(ParameterizedAssertionError a) {
+        assertFalse(a.equals(null));
+    }
+
+    @Test
+    public void canJoinWhenToStringFails() {
+        assertThat(ParameterizedAssertionError.join(" ", new Object() {
+            @Override
+            public String toString() {
+                throw new UnsupportedOperationException();
+            }
+        }), is("[toString failed]"));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/SpecificDataPointsSupplierTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/SpecificDataPointsSupplierTest.java
new file mode 100644
index 0000000..1ba6136
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/internal/SpecificDataPointsSupplierTest.java
@@ -0,0 +1,156 @@
+package org.junit.tests.experimental.theories.internal;
+
+import static org.hamcrest.CoreMatchers.hasItem;
+import static org.hamcrest.CoreMatchers.hasItems;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.FromDataPoints;
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.experimental.theories.PotentialAssignment;
+import org.junit.experimental.theories.PotentialAssignment.CouldNotGenerateValueException;
+import org.junit.experimental.theories.internal.SpecificDataPointsSupplier;
+import org.junit.runners.model.TestClass;
+
+public class SpecificDataPointsSupplierTest {
+
+    public static class TestClassWithNamedDataPoints {
+
+        @DataPoints({"field", "named"})
+        public static String[] values = new String[] { "named field" };
+
+        @DataPoints
+        public static String[] otherValues = new String[] { "other" };
+        
+        @DataPoints({"method", "named"})
+        public static String[] getValues() {
+            return new String[] { "named method" };
+        }
+        
+        @DataPoint({"single", "named"})
+        public static String singleValue = "named single value";
+        
+        @DataPoint
+        public static String otherSingleValue = "other value";
+        
+        @DataPoint({"singlemethod", "named"})
+        public static String getSingleValue() { 
+            return "named single method value";
+        }
+        
+        @DataPoint
+        public static String getSingleOtherValue() {
+            return "other single method value";
+        }
+         
+        @DataPoints
+        public static String[] getOtherValues() {
+            return new String[] { "other method" };
+        }
+    }
+
+    @Test
+    public void shouldReturnOnlyTheNamedDataPoints() throws Throwable {
+        SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));
+
+        List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingAllNamedStrings"));
+        List<String> assignedStrings = getStringValuesFromAssignments(assignments);
+
+        assertEquals(4, assignedStrings.size());
+        assertThat(assignedStrings, hasItems("named field", "named method", "named single value", "named single method value"));
+    }
+    
+    @Test
+    public void shouldReturnOnlyTheNamedFieldDataPoints() throws Throwable {
+        SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));
+
+        List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingNamedFieldString"));
+        List<String> assignedStrings = getStringValuesFromAssignments(assignments);
+
+        assertEquals(1, assignedStrings.size());
+        assertThat(assignedStrings, hasItem("named field"));
+    }
+
+    @Test
+    public void shouldReturnOnlyTheNamedMethodDataPoints() throws Throwable {
+        SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));
+
+        List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingNamedMethodString"));
+        List<String> assignedStrings = getStringValuesFromAssignments(assignments);
+
+        assertEquals(1, assignedStrings.size());
+        assertThat(assignedStrings, hasItem("named method"));
+    }
+    
+    @Test
+    public void shouldReturnOnlyTheNamedSingleFieldDataPoints() throws Throwable {
+        SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));
+
+        List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingNamedSingleFieldString"));
+        List<String> assignedStrings = getStringValuesFromAssignments(assignments);
+
+        assertEquals(1, assignedStrings.size());
+        assertThat(assignedStrings, hasItem("named single value"));
+    }
+
+    @Test
+    public void shouldReturnOnlyTheNamedSingleMethodDataPoints() throws Throwable {
+        SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));
+
+        List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingNamedSingleMethodString"));
+        List<String> assignedStrings = getStringValuesFromAssignments(assignments);
+
+        assertEquals(1, assignedStrings.size());
+        assertThat(assignedStrings, hasItem("named single method value"));
+    }    
+    
+    @Test
+    public void shouldReturnNothingIfTheNamedDataPointsAreMissing() throws Throwable {
+        SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));
+
+        List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingWrongNamedString"));
+        List<String> assignedStrings = getStringValuesFromAssignments(assignments);
+
+        assertEquals(0, assignedStrings.size());
+    }
+
+    private List<String> getStringValuesFromAssignments(List<PotentialAssignment> assignments) throws CouldNotGenerateValueException {
+        List<String> stringValues = new ArrayList<String>();
+        for (PotentialAssignment assignment : assignments) {
+            stringValues.add((String) assignment.getValue());
+        }
+        return stringValues;
+    }
+
+    private ParameterSignature signature(String methodName) throws Exception {
+        return ParameterSignature.signatures(this.getClass().getMethod(methodName, String.class)).get(0);
+    }
+
+    public void methodWantingAnyString(String input) {
+    }
+
+    public void methodWantingNamedFieldString(@FromDataPoints("field") String input) {
+    }
+    
+    public void methodWantingNamedMethodString(@FromDataPoints("method") String input) {
+    }
+    
+    public void methodWantingNamedSingleFieldString(@FromDataPoints("single") String input) {
+    }
+    
+    public void methodWantingNamedSingleMethodString(@FromDataPoints("singlemethod") String input) {
+    }
+    
+    public void methodWantingAllNamedStrings(@FromDataPoints("named") String input) {
+    }
+
+    public void methodWantingWrongNamedString(@FromDataPoints("invalid name") String input) {
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/AllTheoriesRunnerTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/AllTheoriesRunnerTests.java
new file mode 100644
index 0000000..26465ca
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/AllTheoriesRunnerTests.java
@@ -0,0 +1,24 @@
+package org.junit.tests.experimental.theories.runner;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        FailingDataPointMethods.class,
+        SuccessfulWithDataPointFields.class,
+        TheoriesPerformanceTest.class,
+        TypeMatchingBetweenMultiDataPointsMethod.class,
+        UnsuccessfulWithDataPointFields.class,
+        WhenNoParametersMatch.class,
+        WithAutoGeneratedDataPoints.class,
+        WithDataPointMethod.class,
+        WithExtendedParameterSources.class,
+        WithNamedDataPoints.class,
+        WithOnlyTestAnnotations.class,
+        WithParameterSupplier.class,
+        WithUnresolvedGenericTypeVariablesOnTheoryParms.class
+})
+public class AllTheoriesRunnerTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/FailingDataPointMethods.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/FailingDataPointMethods.java
new file mode 100644
index 0000000..f69e502
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/FailingDataPointMethods.java
@@ -0,0 +1,136 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+
+public class FailingDataPointMethods {
+    
+    @RunWith(Theories.class)
+    public static class HasFailingSingleDataPointMethod {
+        @DataPoint
+        public static int num = 10;
+
+        @DataPoint
+        public static int failingDataPoint() {
+            throw new RuntimeException();
+        }
+
+        @Theory
+        public void theory(int x) {
+        }
+    }
+
+    @Test
+    public void shouldFailFromExceptionsInSingleDataPointMethods() {
+        assertThat(testResult(HasWronglyIgnoredFailingSingleDataPointMethod.class), not(isSuccessful()));
+    }
+    
+    @RunWith(Theories.class)
+    public static class HasFailingDataPointArrayMethod {
+        @DataPoints
+        public static int[] num = { 1, 2, 3 };
+
+        @DataPoints
+        public static int[] failingDataPoints() {
+            throw new RuntimeException();
+        }
+
+        @Theory
+        public void theory(int x) {
+        }
+    }
+
+    @Test
+    public void shouldFailFromExceptionsInDataPointArrayMethods() {
+        assertThat(testResult(HasFailingDataPointArrayMethod.class), not(isSuccessful()));
+    }
+    
+    @RunWith(Theories.class)
+    public static class HasIgnoredFailingSingleDataPointMethod {
+        @DataPoint
+        public static int num = 10;
+
+        @DataPoint(ignoredExceptions=Throwable.class)
+        public static int failingDataPoint() {
+            throw new RuntimeException();
+        }
+
+        @Theory
+        public void theory(int x) {
+        }
+    }
+    
+    @Test
+    public void shouldIgnoreSingleDataPointMethodExceptionsOnRequest() {
+        assertThat(testResult(HasIgnoredFailingSingleDataPointMethod.class), isSuccessful());
+    }
+    
+    @RunWith(Theories.class)
+    public static class HasIgnoredFailingMultipleDataPointMethod {
+        @DataPoint
+        public static int num = 10;
+
+        @DataPoints(ignoredExceptions=Throwable.class)
+        public static int[] failingDataPoint() {
+            throw new RuntimeException();
+        }
+
+        @Theory
+        public void theory(int x) {
+        }
+    }
+    
+    @Test
+    public void shouldIgnoreMultipleDataPointMethodExceptionsOnRequest() {
+        assertThat(testResult(HasIgnoredFailingMultipleDataPointMethod.class), isSuccessful());
+    }
+    
+    @RunWith(Theories.class)
+    public static class HasWronglyIgnoredFailingSingleDataPointMethod {
+        @DataPoint
+        public static int num = 10;
+
+        @DataPoint(ignoredExceptions=NullPointerException.class)
+        public static int failingDataPoint() {
+            throw new RuntimeException();
+        }
+
+        @Theory
+        public void theory(int x) {
+        }
+    }    
+    
+    @Test
+    public void shouldNotIgnoreNonMatchingSingleDataPointExceptions() {
+        assertThat(testResult(HasWronglyIgnoredFailingSingleDataPointMethod.class), not(isSuccessful()));
+    }
+    
+    @RunWith(Theories.class)
+    public static class HasWronglyIgnoredFailingMultipleDataPointMethod {
+        @DataPoint
+        public static int num = 10;
+
+        @DataPoint(ignoredExceptions=NullPointerException.class)
+        public static int failingDataPoint() {
+            throw new RuntimeException();
+        }
+
+        @Theory
+        public void theory(int x) {
+        }
+    }    
+    
+    @Test
+    public void shouldNotIgnoreNonMatchingMultipleDataPointExceptions() {
+        assertThat(testResult(HasWronglyIgnoredFailingMultipleDataPointMethod.class), not(isSuccessful()));
+    }
+    
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/SuccessfulWithDataPointFields.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/SuccessfulWithDataPointFields.java
new file mode 100644
index 0000000..80cfd89
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/SuccessfulWithDataPointFields.java
@@ -0,0 +1,211 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+
+@RunWith(Enclosed.class)
+public class SuccessfulWithDataPointFields {
+    @RunWith(Theories.class)
+    public static class HasATwoParameterTheory {
+        @DataPoint
+        public static int ONE = 1;
+
+        @Theory
+        public void allIntsAreEqual(int x, int y) {
+            assertThat(x, is(y));
+        }
+    }
+
+    @RunWith(Theories.class)
+    public static class BeforeAndAfterOnSameInstance {
+        @DataPoint
+        public static String A = "A";
+
+        private int befores = 0;
+
+        @Before
+        public void incrementBefore() {
+            befores++;
+        }
+
+        @Theory
+        public void stringsAreOK(String string) {
+            assertTrue(befores == 1);
+        }
+    }
+
+    @RunWith(Theories.class)
+    public static class NewObjectEachTime {
+        @DataPoint
+        public static String A = "A";
+
+        @DataPoint
+        public static String B = "B";
+
+        private List<String> list = new ArrayList<String>();
+
+        @Theory
+        public void addToEmptyList(String string) {
+            list.add(string);
+            assertThat(list.size(), is(1));
+        }
+    }
+
+    @RunWith(Theories.class)
+    public static class PositiveInts {
+        @DataPoint
+        public static final int ONE = 1;
+
+        private int x;
+
+        public PositiveInts(int x) {
+            assumeTrue(x > 0);
+            this.x = x;
+        }
+
+        @Theory
+        public void haveAPostiveSquare() {
+            assertTrue(x * x > 0);
+        }
+    }
+
+    @RunWith(Theories.class)
+    public static class PositiveIntsWithNegativeField {
+        @DataPoint
+        public static final int ONE = 1;
+        @DataPoint
+        public static final int NEGONE = -1;
+
+        private int x;
+
+        public PositiveIntsWithNegativeField(int x) {
+            assumeTrue(x > 0);
+            this.x = x;
+        }
+
+        @Theory
+        public void haveAPostiveSquare() {
+            assertTrue(x > 0);
+        }
+    }
+
+    @RunWith(Theories.class)
+    public static class PositiveIntsWithMethodParams {
+        @DataPoint
+        public static final int ONE = 1;
+
+        private int x;
+
+        public PositiveIntsWithMethodParams(int x) {
+            assumeTrue(x > 0);
+            this.x = x;
+        }
+
+        @Theory
+        public void haveAPostiveSquare(int y) {
+            assumeTrue(y > 0);
+            assertTrue(x * y > 0);
+        }
+    }
+
+    @RunWith(Theories.class)
+    public static class DifferentTypesInConstructor {
+        @DataPoint
+        public static final int ONE = 1;
+
+        @DataPoint
+        public static final String A = "A";
+
+        public DifferentTypesInConstructor(int x) {
+        }
+
+        @Theory
+        public void yesIndeed(String a) {
+        }
+    }
+
+    @RunWith(Theories.class)
+    public static class BeforeAndAfterEachTime {
+        public static int befores = 0;
+
+        @DataPoint
+        public static String A = "A";
+
+        @DataPoint
+        public static String B = "B";
+
+        @Before
+        public void incrementBefore() {
+            befores++;
+        }
+
+        @BeforeClass
+        public static void resetCalls() {
+            befores = 0;
+        }
+
+        @Theory
+        public void stringsAreOK(String string) {
+        }
+
+        @AfterClass
+        public static void calledTwice() {
+            assertEquals(2, befores);
+        }
+    }
+
+    @RunWith(Theories.class)
+    public static class OneTestTwoAnnotations {
+        public static int tests = 0;
+
+        @DataPoint
+        public static String A = "A";
+
+        @BeforeClass
+        public static void resetCalls() {
+            tests = 0;
+        }
+
+        @Theory
+        @Test
+        public void stringsAreOK(String string) {
+            tests++;
+        }
+
+        @AfterClass
+        public static void calledTwice() {
+            assertEquals(1, tests);
+        }
+    }
+
+    @RunWith(Theories.class)
+    public static class StaticPublicNonDataPoints {
+        // DataPoint which passes the test
+        @DataPoint
+        public static int ZERO = 0;
+
+        // Not annotated as a DataPoint and therefore should be ignored:
+        public static int ONE = 1;
+
+        @Theory
+        public void onlyAnnotatedFields(int i) {
+            assertTrue(i == 0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/TheoriesPerformanceTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/TheoriesPerformanceTest.java
new file mode 100644
index 0000000..9275524
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/TheoriesPerformanceTest.java
@@ -0,0 +1,38 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeTrue;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+
+public class TheoriesPerformanceTest {
+    @RunWith(Theories.class)
+    public static class UpToTen {
+        @DataPoints
+        public static int[] ints = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+
+        @Theory
+        public void threeInts(int x, int y, int z) {
+            // pass always
+        }
+    }
+
+    private static final boolean TESTING_PERFORMANCE = false;
+
+    // If we do not share the same instance of TestClass, repeatedly parsing the
+    // class's annotations looking for @Befores and @Afters gets really costly.
+    //
+    // Likewise, the TestClass must be passed into AllMembersSupplier, or the
+    // annotation parsing is again costly.
+    @Test
+    public void tryCombinationsQuickly() {
+        assumeTrue(TESTING_PERFORMANCE);
+        assertThat(testResult(UpToTen.class), isSuccessful());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/TypeMatchingBetweenMultiDataPointsMethod.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/TypeMatchingBetweenMultiDataPointsMethod.java
new file mode 100644
index 0000000..4b7e878
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/TypeMatchingBetweenMultiDataPointsMethod.java
@@ -0,0 +1,57 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+
+public class TypeMatchingBetweenMultiDataPointsMethod {
+
+    @RunWith(Theories.class)
+    public static class WithWrongfullyTypedDataPointsMethod {
+        @DataPoint
+        public static String[] correctlyTyped = {"Good", "Morning"};
+
+        @DataPoints
+        public static String[] wrongfullyTyped() {
+            return new String[]{"Hello", "World"};
+        }
+
+        @Theory
+        public void testTheory(String[] array) {
+        }
+    }
+
+    @Test
+    public void ignoreWrongTypedDataPointsMethod() {
+        assertThat(testResult(WithWrongfullyTypedDataPointsMethod.class), isSuccessful());
+    }
+
+    @RunWith(Theories.class)
+    public static class WithCorrectlyTypedDataPointsMethod {
+        @DataPoint
+        public static String[] correctlyTyped = {"Good", "Morning"};
+
+        @DataPoints
+        public static String[][] anotherCorrectlyTyped() {
+            return new String[][]{
+                    {"Hello", "World"}
+            };
+        }
+
+        @Theory
+        public void testTheory(String[] array) {
+        }
+    }
+
+    @Test
+    public void pickUpMultiPointDataPointMethods() throws Exception {
+        assertThat(testResult(WithCorrectlyTypedDataPointsMethod.class), isSuccessful());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/UnsuccessfulWithDataPointFields.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/UnsuccessfulWithDataPointFields.java
new file mode 100644
index 0000000..57dec2d
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/UnsuccessfulWithDataPointFields.java
@@ -0,0 +1,243 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.hasFailureContaining;
+import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining;
+import org.hamcrest.CoreMatchers;
+import org.junit.Test;
+import org.junit.experimental.results.PrintableResult;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+import org.junit.runners.model.TestClass;
+
+public class UnsuccessfulWithDataPointFields {
+    @RunWith(Theories.class)
+    public static class HasAFailingTheory {
+        @DataPoint
+        public static int ONE = 1;
+
+        @Theory
+        public void everythingIsZero(int x) {
+            assertThat(x, is(0));
+        }
+    }
+
+    @Test
+    public void theoryClassMethodsShowUp() throws Exception {
+        assertThat(new Theories(HasAFailingTheory.class).getDescription()
+                .getChildren().size(), is(1));
+    }
+
+    @Test
+    public void theoryAnnotationsAreRetained() throws Exception {
+        assertThat(new TestClass(HasAFailingTheory.class).getAnnotatedMethods(
+                Theory.class).size(), is(1));
+    }
+
+    @Test
+    public void canRunTheories() throws Exception {
+        assertThat(testResult(HasAFailingTheory.class),
+                hasSingleFailureContaining("Expected"));
+    }
+
+    @RunWith(Theories.class)
+    public static class DoesntUseParams {
+        @DataPoint
+        public static int ONE = 1;
+
+        @Theory
+        public void everythingIsZero(int x, int y) {
+            assertThat(2, is(3));
+        }
+    }
+
+    @Test
+    public void reportBadParams() throws Exception {
+        assertThat(testResult(DoesntUseParams.class),
+                hasSingleFailureContaining("everythingIsZero(\"1\" <from ONE>, \"1\" <from ONE>)"));
+    }
+
+    @RunWith(Theories.class)
+    public static class NullsOK {
+        @DataPoint
+        public static String NULL = null;
+
+        @DataPoint
+        public static String A = "A";
+
+        @Theory
+        public void everythingIsA(String a) {
+            assertThat(a, is("A"));
+        }
+    }
+
+    @Test
+    public void nullsUsedUnlessProhibited() throws Exception {
+        assertThat(testResult(NullsOK.class),
+                hasSingleFailureContaining("null"));
+    }
+    
+    @RunWith(Theories.class)
+    public static class TheoriesMustBePublic {
+        @DataPoint
+        public static int THREE = 3;
+
+        @Theory
+        void numbers(int x) {
+
+        }
+    }
+
+    @Test
+    public void theoriesMustBePublic() {
+        assertThat(
+                testResult(TheoriesMustBePublic.class),
+                hasSingleFailureContaining("public"));
+    }    
+
+    @RunWith(Theories.class)
+    public static class DataPointFieldsMustBeStatic {
+        @DataPoint
+        public int THREE = 3;
+        
+        @DataPoints
+        public int[] FOURS = new int[] { 4 };
+        
+        @Theory
+        public void numbers(int x) {
+
+        }
+    }
+
+    @Test
+    public void dataPointFieldsMustBeStatic() {
+        assertThat(
+                testResult(DataPointFieldsMustBeStatic.class),
+                CoreMatchers.<PrintableResult>both(hasFailureContaining("DataPoint field THREE must be static"))
+                        .and(hasFailureContaining("DataPoint field FOURS must be static")));
+    }
+    
+    @RunWith(Theories.class)
+    public static class DataPointMethodsMustBeStatic {
+        @DataPoint
+        public int singleDataPointMethod() {
+            return 1;
+        }
+        
+        @DataPoints
+        public int[] dataPointArrayMethod() {
+            return new int[] { 1, 2, 3 };
+        }
+
+        @Theory
+        public void numbers(int x) {
+            
+        }
+    }
+    
+    @Test
+    public void dataPointMethodsMustBeStatic() {
+        assertThat(
+                testResult(DataPointMethodsMustBeStatic.class),
+                CoreMatchers.<PrintableResult>both(
+                        hasFailureContaining("DataPoint method singleDataPointMethod must be static"))
+                .and(
+                        hasFailureContaining("DataPoint method dataPointArrayMethod must be static")));
+    }
+
+    @RunWith(Theories.class)
+    public static class DataPointFieldsMustBePublic {
+        @DataPoint
+        static int THREE = 3;
+        
+        @DataPoints
+        static int[] THREES = new int[] { 3 };
+
+        @DataPoint
+        protected static int FOUR = 4;
+        
+        @DataPoints
+        protected static int[] FOURS = new int[] { 4 };
+
+        @DataPoint
+        private static int FIVE = 5;
+        
+        @DataPoints
+        private static int[] FIVES = new int[] { 5 };
+
+        @Theory
+        public void numbers(int x) {
+        	
+        }
+    }
+
+    @Test
+    public void dataPointFieldsMustBePublic() {
+        PrintableResult result = testResult(DataPointFieldsMustBePublic.class);        
+
+        assertThat(result,
+                allOf(hasFailureContaining("DataPoint field THREE must be public"),
+                      hasFailureContaining("DataPoint field THREES must be public"),
+                      hasFailureContaining("DataPoint field FOUR must be public"),
+                      hasFailureContaining("DataPoint field FOURS must be public"),
+                      hasFailureContaining("DataPoint field FIVE must be public"),
+                      hasFailureContaining("DataPoint field FIVES must be public")));
+    }
+
+    @RunWith(Theories.class)
+    public static class DataPointMethodsMustBePublic {
+        @DataPoint
+        static int three() {
+            return 3;
+        }
+        
+        @DataPoints
+        static int[] threes() { 
+            return new int[] { 3 };
+        }
+
+        @DataPoint
+        protected static int four() {
+            return 4;
+        }
+        
+        @DataPoints
+        protected static int[] fours() {
+            return new int[] { 4 };
+        }
+
+        @DataPoint
+        private static int five() {
+            return 5;
+        }
+        
+        @DataPoints
+        private static int[] fives() {
+            return new int[] { 5 };
+        }
+
+        @Theory
+        public void numbers(int x) {
+        	
+        }
+    }
+    
+    @Test
+    public void dataPointMethodsMustBePublic() {
+        PrintableResult result = testResult(DataPointMethodsMustBePublic.class);        
+
+        assertThat(result,
+                allOf(hasFailureContaining("DataPoint method three must be public"),
+                      hasFailureContaining("DataPoint method threes must be public"),
+                      hasFailureContaining("DataPoint method four must be public"),
+                      hasFailureContaining("DataPoint method fours must be public"),
+                      hasFailureContaining("DataPoint method five must be public"),
+                      hasFailureContaining("DataPoint method fives must be public")));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WhenNoParametersMatch.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WhenNoParametersMatch.java
new file mode 100644
index 0000000..a8e3a84
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WhenNoParametersMatch.java
@@ -0,0 +1,51 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assume.assumeThat;
+import static org.junit.experimental.results.PrintableResult.testResult;
+
+import org.hamcrest.Matcher;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+
+@RunWith(Theories.class)
+public class WhenNoParametersMatch {
+    @DataPoints
+    public static int[] ints = {0, 1, 3, 5, 1776};
+
+    @DataPoints
+    public static Matcher<?>[] matchers = {not(0), is(1)};
+
+    @RunWith(Theories.class)
+    public static class AssumptionsFail {
+        @DataPoint
+        public static int DATA = 0;
+
+        @DataPoint
+        public static Matcher<Integer> MATCHER = null;
+
+        @Theory
+        public void nonZeroIntsAreFun(int x) {
+            assumeThat(x, MATCHER);
+        }
+    }
+
+    @Theory
+    public void showFailedAssumptionsWhenNoParametersFound(int data,
+            Matcher<Integer> matcher) throws Exception {
+        assumeThat(data, not(matcher));
+        AssumptionsFail.DATA = data;
+        AssumptionsFail.MATCHER = matcher;
+
+        String result = testResult(AssumptionsFail.class).toString();
+
+        assertThat(result, containsString(matcher.toString()));
+        assertThat(result, containsString("" + data));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithAutoGeneratedDataPoints.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithAutoGeneratedDataPoints.java
new file mode 100644
index 0000000..53cab04
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithAutoGeneratedDataPoints.java
@@ -0,0 +1,71 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.tests.experimental.theories.TheoryTestUtils.potentialAssignments;
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.Theories;
+import org.junit.runner.RunWith;
+
+public class WithAutoGeneratedDataPoints {
+
+    private enum ENUM { VALUE, OTHER_VALUE, THIRD_VALUE }
+    
+    @RunWith(Theories.class)
+    public static class TheoryTestClassWithAutogeneratedParameterValues {
+        
+        public void theory(ENUM e) {
+        }
+        
+        public void theory(boolean b) {
+        }
+        
+    }
+    
+    @Test
+    public void shouldAutomaticallyGenerateEnumDataPoints() throws Throwable {
+        assertEquals(ENUM.values().length, potentialAssignments(
+                TheoryTestClassWithAutogeneratedParameterValues.class.getMethod("theory", ENUM.class)).size());
+    }
+    
+    @Test
+    public void shouldAutomaticallyGenerateBooleanDataPoints() throws Throwable {
+        assertEquals(2, potentialAssignments(
+                TheoryTestClassWithAutogeneratedParameterValues.class.getMethod("theory", boolean.class)).size());
+    }
+    
+    @RunWith(Theories.class)
+    public static class TheoryTestClassWithSpecificEnumDataPoint {
+        
+        @DataPoint
+        public static ENUM value = ENUM.OTHER_VALUE;
+        
+        public void theory(ENUM e) {
+        }
+        
+    }
+    
+    @Test
+    public void shouldNotAutogenerateEnumDataPointsWhenSpecificDataPointGiven() throws Throwable {
+        assertEquals(1, potentialAssignments(
+                TheoryTestClassWithSpecificEnumDataPoint.class.getMethod("theory", ENUM.class)).size());
+    }
+    
+    @RunWith(Theories.class)
+    public static class TheoryTestClassWithSpecificBooleanDataPoint {
+        
+        @DataPoint
+        public static boolean value = true;
+        
+        public void theory(boolean b) {
+        }
+        
+    }
+    
+    @Test
+    public void shouldNotAutogenerateBooleanDataPointsWhenSpecificDataPointGiven() throws Throwable {
+        assertEquals(1, potentialAssignments(
+                TheoryTestClassWithSpecificBooleanDataPoint.class.getMethod("theory", boolean.class)).size());
+    }    
+    
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithDataPointMethod.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithDataPointMethod.java
new file mode 100644
index 0000000..f2b2753
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithDataPointMethod.java
@@ -0,0 +1,114 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.everyItem;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+import static org.junit.tests.experimental.theories.TheoryTestUtils.potentialAssignments;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import org.hamcrest.Matcher;
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.RunWith;
+import org.junit.runner.notification.Failure;
+
+public class WithDataPointMethod {
+    @RunWith(Theories.class)
+    public static class HasDataPointMethod {
+        @DataPoint
+        public static int oneHundred() {
+            return 100;
+        }
+
+        @Theory
+        public void allIntsOk(int x) {
+        }
+    }
+
+    @Test
+    public void pickUpDataPointMethods() {
+        assertThat(testResult(HasDataPointMethod.class), isSuccessful());
+    }
+
+    @RunWith(Theories.class)
+    public static class DataPointMethodReturnsMutableObject {
+        @DataPoint
+        public static List<Object> empty() {
+            return new ArrayList<Object>();
+        }
+
+        @DataPoint
+        public static int ONE = 1;
+
+        @DataPoint
+        public static int TWO = 2;
+
+        @Theory
+        public void everythingsEmpty(List<Object> first, int number) {
+            assertThat(first.size(), is(0));
+            first.add("a");
+        }
+    }
+
+    @Test
+    public void mutableObjectsAreCreatedAfresh() {
+        assertThat(failures(DataPointMethodReturnsMutableObject.class), empty());
+    }
+
+    @RunWith(Theories.class)
+    public static class HasDateMethod {
+        @DataPoint
+        public static int oneHundred() {
+            return 100;
+        }
+
+        public static Date notADataPoint() {
+            return new Date();
+        }
+
+        @Theory
+        public void allIntsOk(int x) {
+        }
+
+        @Theory
+        public void onlyStringsOk(String s) {
+        }
+
+        @Theory
+        public void onlyDatesOk(Date d) {
+        }
+    }
+
+    @Test
+    public void ignoreDataPointMethodsWithWrongTypes() throws Throwable {
+        assertThat(potentialAssignments(
+                HasDateMethod.class.getMethod("onlyStringsOk", String.class))
+                .toString(), not(containsString("100")));
+    }
+
+    @Test
+    public void ignoreDataPointMethodsWithoutAnnotation() throws Throwable {
+        assertThat(potentialAssignments(
+                HasDateMethod.class.getMethod("onlyDatesOk", Date.class))
+                .size(), is(0));
+    }
+
+    private List<Failure> failures(Class<?> type) {
+        return JUnitCore.runClasses(type).getFailures();
+    }
+
+    private Matcher<Iterable<Failure>> empty() {
+        return everyItem(nullValue(Failure.class));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithExtendedParameterSources.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithExtendedParameterSources.java
new file mode 100644
index 0000000..c08839f
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithExtendedParameterSources.java
@@ -0,0 +1,180 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import org.junit.Test;
+import org.junit.experimental.results.ResultMatchers;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.experimental.theories.suppliers.TestedOn;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.RunWith;
+
+public class WithExtendedParameterSources {
+    @RunWith(Theories.class)
+    public static class ParameterAnnotations {
+        @Theory
+        public void everythingIsOne(@TestedOn(ints = {1})
+        int number) {
+            assertThat(number, is(1));
+        }
+    }
+
+    @Test
+    public void testedOnLimitsParameters() throws Exception {
+        assertThat(testResult(ParameterAnnotations.class), ResultMatchers
+                .isSuccessful());
+    }
+
+    @RunWith(Theories.class)
+    public static class ShouldFilterOutNullSingleDataPoints {
+
+        @DataPoint
+        public static String A = "a";
+        
+        @DataPoint
+        public static String NULL = null;
+
+        @Theory(nullsAccepted = false)
+        public void allStringsAreNonNull(String s) {
+            assertThat(s, notNullValue());
+        }
+    }
+
+    @Test
+    public void shouldFilterOutNullSingleDataPoints() {
+        assertThat(testResult(ShouldFilterOutNullSingleDataPoints.class), isSuccessful());
+    }
+
+    @RunWith(Theories.class)
+    public static class ShouldFilterOutNullElementsFromDataPointArrays {
+        @DataPoints
+        public static String[] SOME_NULLS = { "non-null", null };
+
+        @Theory(nullsAccepted = false)
+        public void allStringsAreNonNull(String s) {
+            assertThat(s, notNullValue());
+        }
+    }
+
+    @Test
+    public void shouldFilterOutNullElementsFromDataPointArrays() {
+        assertThat(testResult(ShouldFilterOutNullElementsFromDataPointArrays.class), isSuccessful());
+    }
+    
+    @RunWith(Theories.class)
+    public static class ShouldRejectTheoriesWithOnlyDisallowedNullData {
+        @DataPoints
+        public static String value = null;
+
+        @Theory(nullsAccepted = false)
+        public void allStringsAreNonNull(String s) {
+        }
+    }
+
+    @Test
+    public void ShouldRejectTheoriesWithOnlyDisallowedNullData() {
+        assertThat(testResult(ShouldRejectTheoriesWithOnlyDisallowedNullData.class), not(isSuccessful()));
+    }    
+
+    @RunWith(Theories.class)
+    public static class DataPointArrays {
+        public static String log = "";
+
+        @DataPoints
+        public static String[] STRINGS = new String[]{"A", "B"};
+
+        @Theory
+        public void addToLog(String string) {
+            log += string;
+        }
+    }
+
+    @Test
+    public void getDataPointsFromArray() {
+        DataPointArrays.log = "";
+        JUnitCore.runClasses(DataPointArrays.class);
+        assertThat(DataPointArrays.log, is("AB"));
+    }
+
+    @RunWith(Theories.class)
+    public static class DataPointArrayMethod {
+        public static String log = "";
+
+        @DataPoints
+        public static String[] STRINGS() {
+            return new String[]{"A", "B"};
+        }
+
+        @Theory
+        public void addToLog(String string) {
+            log += string;
+        }
+    }
+
+    @Test
+    public void getDataPointsFromArrayMethod() {
+        DataPointArrayMethod.log = "";
+        JUnitCore.runClasses(DataPointArrayMethod.class);
+        assertThat(DataPointArrayMethod.log, is("AB"));
+    }
+
+    @RunWith(Theories.class)
+    public static class DataPointMalformedArrayMethods {
+        public static String log = "";
+
+        @DataPoints
+        public static String[] STRINGS() {
+            return new String[]{"A", "B"};
+        }
+
+        @DataPoints
+        public static String STRING() {
+            return "C";
+        }
+
+        @DataPoints
+        public static int[] INTS() {
+            return new int[]{1, 2, 3};
+        }
+
+        @Theory
+        public void addToLog(String string) {
+            log += string;
+        }
+    }
+
+    @Test
+    public void getDataPointsFromArrayMethodInSpiteOfMalformedness() {
+        DataPointArrayMethod.log = "";
+        JUnitCore.runClasses(DataPointArrayMethod.class);
+        assertThat(DataPointArrayMethod.log, is("AB"));
+    }
+
+    @RunWith(Theories.class)
+    public static class DataPointArrayToBeUsedForWholeParameter {
+        public static String log = "";
+
+        @DataPoint
+        public static String[] STRINGS = new String[]{"A", "B"};
+
+        @Theory
+        public void addToLog(String[] strings) {
+            log += strings[0];
+        }
+    }
+
+    @Test
+    public void dataPointCanBeArray() {
+        DataPointArrayToBeUsedForWholeParameter.log = "";
+        JUnitCore.runClasses(DataPointArrayToBeUsedForWholeParameter.class);
+        assertThat(DataPointArrayToBeUsedForWholeParameter.log, is("A"));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithNamedDataPoints.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithNamedDataPoints.java
new file mode 100644
index 0000000..8383a47
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithNamedDataPoints.java
@@ -0,0 +1,73 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.tests.experimental.theories.TheoryTestUtils.potentialAssignments;
+
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.FromDataPoints;
+import org.junit.experimental.theories.PotentialAssignment;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+
+public class WithNamedDataPoints {
+
+    @RunWith(Theories.class)
+    public static class HasSpecificDatapointsParameters {
+        
+        @DataPoints
+        public static String[] badStrings = new String[] { "bad" };
+        
+        @DataPoint
+        public static String badString = "also bad";
+        
+        @DataPoints("named")
+        public static String[] goodStrings = new String[] { "expected", "also expected" };
+        
+        @DataPoint("named")
+        public static String goodString = "expected single value";
+        
+        @DataPoints("named")
+        public static String[] methodStrings() {
+            return new String[] { "expected method value" };
+        }
+        
+        @DataPoint("named")
+        public static String methodString() {
+            return "expected single method string";
+        }
+        
+        @DataPoints
+        public static String[] otherMethod() {
+            return new String[] { "other method value" };
+        }
+        
+        @DataPoint
+        public static String otherSingleValueMethod() {
+            return "other single value string";
+        }
+        
+        @Theory
+        public void theory(@FromDataPoints("named") String param) {
+        }
+        
+    }
+    
+    @Test
+    public void onlyUseSpecificDataPointsIfSpecified() throws Throwable {
+        List<PotentialAssignment> assignments = potentialAssignments(HasSpecificDatapointsParameters.class
+                .getMethod("theory", String.class));
+        
+        assertEquals(5, assignments.size());
+        for (PotentialAssignment assignment : assignments) {
+            assertThat((String) assignment.getValue(), containsString("expected"));
+        }
+    }
+    
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithOnlyTestAnnotations.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithOnlyTestAnnotations.java
new file mode 100644
index 0000000..17b2665
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithOnlyTestAnnotations.java
@@ -0,0 +1,82 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.failureCountIs;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import org.junit.Test;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.Theories;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+
+public class WithOnlyTestAnnotations {
+    @RunWith(Theories.class)
+    public static class HonorExpectedException {
+        @Test(expected = NullPointerException.class)
+        public void shouldThrow() {
+
+        }
+    }
+
+    @Test
+    public void honorExpected() throws Exception {
+        assertThat(testResult(HonorExpectedException.class).failureCount(), is(1));
+    }
+
+    @RunWith(Theories.class)
+    public static class HonorExpectedExceptionPasses {
+        @Test(expected = NullPointerException.class)
+        public void shouldThrow() {
+            throw new NullPointerException();
+        }
+    }
+
+    @Test
+    public void honorExpectedPassing() throws Exception {
+        assertThat(testResult(HonorExpectedExceptionPasses.class), isSuccessful());
+    }
+
+    @RunWith(Theories.class)
+    public static class HonorTimeout {
+        @Test(timeout = 5)
+        public void shouldStop() {
+            while (true) {
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException e) {
+
+                }
+            }
+        }
+    }
+
+    @Test
+    public void honorTimeout() throws Exception {
+        assertThat(testResult(HonorTimeout.class), failureCountIs(1));
+    }
+
+    @RunWith(Theories.class)
+    static public class ErrorWhenTestHasParametersDespiteTheories {
+        @DataPoint
+        public static int ZERO = 0;
+
+        @Test
+        public void testMethod(int i) {
+        }
+    }
+
+    @Test
+    public void testErrorWhenTestHasParametersDespiteTheories() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(ErrorWhenTestHasParametersDespiteTheories.class);
+        assertEquals(1, result.getFailureCount());
+        String message = result.getFailures().get(0).getMessage();
+        assertThat(message, containsString("should have no parameters"));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithParameterSupplier.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithParameterSupplier.java
new file mode 100644
index 0000000..1802390
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithParameterSupplier.java
@@ -0,0 +1,165 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.tests.experimental.theories.TheoryTestUtils.potentialAssignments;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.theories.ParameterSignature;
+import org.junit.experimental.theories.ParameterSupplier;
+import org.junit.experimental.theories.ParametersSuppliedBy;
+import org.junit.experimental.theories.PotentialAssignment;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.TestClass;
+
+public class WithParameterSupplier {
+    
+    @Rule
+    public ExpectedException expected = ExpectedException.none();
+
+    private static class SimplePotentialAssignment extends PotentialAssignment {
+        private String description;
+        private Object value;
+
+        public SimplePotentialAssignment(Object value, String description) {
+            this.value = value;
+            this.description = description;
+        }
+
+        @Override
+        public Object getValue() throws CouldNotGenerateValueException {
+            return value;
+        }
+
+        @Override
+        public String getDescription() throws CouldNotGenerateValueException {
+            return description;
+        }
+    }
+
+    private static final List<String> DATAPOINTS = Arrays.asList("qwe", "asd");
+
+    public static class SimpleSupplier extends ParameterSupplier {
+
+        @Override
+        public List<PotentialAssignment> getValueSources(ParameterSignature sig) {
+            List<PotentialAssignment> assignments = new ArrayList<PotentialAssignment>();
+
+            for (String datapoint : DATAPOINTS) {
+                assignments.add(new SimplePotentialAssignment(datapoint,
+                        datapoint));
+            }
+
+            return assignments;
+        }
+
+    }
+
+    @RunWith(Theories.class)
+    public static class TestClassUsingParameterSupplier {
+
+        @Theory
+        public void theoryMethod(@ParametersSuppliedBy(SimpleSupplier.class) String param) {
+        }
+
+    }
+
+    @Test
+    public void shouldPickUpDataPointsFromParameterSupplier() throws Throwable {
+        List<PotentialAssignment> assignments = potentialAssignments(TestClassUsingParameterSupplier.class
+                .getMethod("theoryMethod", String.class));
+
+        assertEquals(2, assignments.size());
+        assertEquals(DATAPOINTS.get(0), assignments.get(0).getValue());
+        assertEquals(DATAPOINTS.get(1), assignments.get(1).getValue());
+    }
+    
+    public static class SupplierWithUnknownConstructor extends ParameterSupplier {
+        
+        public SupplierWithUnknownConstructor(String param) {
+        }
+
+        @Override
+        public List<PotentialAssignment> getValueSources(ParameterSignature sig) {
+            return null;
+        }
+
+    }
+
+    @RunWith(Theories.class)
+    public static class TestClassUsingSupplierWithUnknownConstructor {
+
+        @Theory
+        public void theory(@ParametersSuppliedBy(SupplierWithUnknownConstructor.class) String param) {
+        }
+
+    }
+    
+    @Test
+    public void shouldRejectSuppliersWithUnknownConstructors() throws Exception {
+        expected.expect(InitializationError.class);
+        new Theories(TestClassUsingSupplierWithUnknownConstructor.class);
+    }
+    
+    public static class SupplierWithTwoConstructors extends ParameterSupplier {
+        
+        public SupplierWithTwoConstructors(String param) {
+        }
+
+        @Override
+        public List<PotentialAssignment> getValueSources(ParameterSignature sig) {
+            return null;
+        }
+
+    }
+
+    @RunWith(Theories.class)
+    public static class TestClassUsingSupplierWithTwoConstructors {
+
+        @Theory
+        public void theory(@ParametersSuppliedBy(SupplierWithTwoConstructors.class) String param) {
+        }
+
+    }
+    
+    @Test
+    public void shouldRejectSuppliersWithTwoConstructors() throws Exception {
+        expected.expect(InitializationError.class);
+        new Theories(TestClassUsingSupplierWithTwoConstructors.class);
+    }
+    
+    public static class SupplierWithTestClassConstructor extends ParameterSupplier {
+        
+        public SupplierWithTestClassConstructor(TestClass param) {
+        }
+
+        @Override
+        public List<PotentialAssignment> getValueSources(ParameterSignature sig) {
+            return null;
+        }
+
+    }
+
+    @RunWith(Theories.class)
+    public static class TestClassUsingSupplierWithTestClassConstructor {
+
+        @Theory
+        public void theory(@ParametersSuppliedBy(SupplierWithTestClassConstructor.class) String param) {
+        }
+
+    }
+    
+    @Test
+    public void shouldAcceptSuppliersWithTestClassConstructor() throws Exception {
+        new Theories(TestClassUsingSupplierWithTestClassConstructor.class);
+    }
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithUnresolvedGenericTypeVariablesOnTheoryParms.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithUnresolvedGenericTypeVariablesOnTheoryParms.java
new file mode 100644
index 0000000..5d46699
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/experimental/theories/runner/WithUnresolvedGenericTypeVariablesOnTheoryParms.java
@@ -0,0 +1,180 @@
+package org.junit.tests.experimental.theories.runner;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.failureCountIs;
+import static org.junit.experimental.results.ResultMatchers.hasFailureContaining;
+import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+import org.junit.experimental.results.PrintableResult;
+import org.junit.experimental.theories.DataPoint;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+
+public class WithUnresolvedGenericTypeVariablesOnTheoryParms {
+    @Test
+    public void whereTypeVariableIsOnTheTheory() {
+        PrintableResult result = testResult(TypeVariableOnTheoryOnly.class);
+        assertThat(result, isSuccessful());
+    }
+
+    @RunWith(Theories.class)
+    public static class TypeVariableOnTheoryOnly {
+        @DataPoint
+        public static List<String> strings = Arrays.asList("foo", "bar");
+
+        @Theory
+        public <T> void forItems(Collection<?> items) {
+        }
+    }
+
+    @Test
+    public void whereTypeVariableIsOnTheoryParm() {
+        PrintableResult result = testResult(TypeVariableOnTheoryParm.class);
+        assertThat(result, hasSingleFailureContaining("unresolved type variable T"));
+    }
+
+    @RunWith(Theories.class)
+    public static class TypeVariableOnTheoryParm {
+        @DataPoint
+        public static String string = "foo";
+
+        @Theory
+        public <T> void forItem(T item) {
+        }
+    }
+
+    @Test
+    public void whereTypeVariableIsOnParameterizedTheoryParm() {
+        PrintableResult result = testResult(TypeVariableOnParameterizedTheoryParm.class);
+        assertThat(result, hasSingleFailureContaining("unresolved type variable T"));
+    }
+
+    @RunWith(Theories.class)
+    public static class TypeVariableOnParameterizedTheoryParm {
+        @DataPoint
+        public static List<String> strings = Arrays.asList("foo", "bar");
+
+        @Theory
+        public <T> void forItems(Collection<T> items) {
+        }
+    }
+
+    @Test
+    public void whereTypeVariableIsOnWildcardUpperBoundOnTheoryParm() {
+        PrintableResult result = testResult(TypeVariableOnWildcardUpperBoundOnTheoryParm.class);
+        assertThat(result, hasSingleFailureContaining("unresolved type variable U"));
+    }
+
+    @RunWith(Theories.class)
+    public static class TypeVariableOnWildcardUpperBoundOnTheoryParm {
+        @DataPoint
+        public static List<String> strings = Arrays.asList("foo", "bar");
+
+        @Theory
+        public <U> void forItems(Collection<? extends U> items) {
+        }
+    }
+
+    @Test
+    public void whereTypeVariableIsOnWildcardLowerBoundOnTheoryParm() {
+        PrintableResult result = testResult(TypeVariableOnWildcardLowerBoundOnTheoryParm.class);
+        assertThat(result, hasSingleFailureContaining("unresolved type variable V"));
+    }
+
+    @RunWith(Theories.class)
+    public static class TypeVariableOnWildcardLowerBoundOnTheoryParm {
+        @DataPoint
+        public static List<String> strings = Arrays.asList("foo", "bar");
+
+        @Theory
+        public <V> void forItems(Collection<? super V> items) {
+        }
+    }
+
+    @Test
+    public void whereTypeVariableIsOnArrayTypeOnTheoryParm() {
+        PrintableResult result = testResult(TypeVariableOnArrayTypeOnTheoryParm.class);
+        assertThat(result, hasSingleFailureContaining("unresolved type variable T"));
+    }
+
+    @RunWith(Theories.class)
+    public static class TypeVariableOnArrayTypeOnTheoryParm {
+        @DataPoints
+        public static String[][] items() {
+            return new String[][]{new String[]{"foo"}, new String[]{"bar"}};
+        }
+
+        @Theory
+        public <T> void forItems(T[] items) {
+        }
+    }
+
+    @Test
+    public void whereTypeVariableIsOnComponentOfArrayTypeOnTheoryParm() {
+        PrintableResult result = testResult(TypeVariableOnComponentOfArrayTypeOnTheoryParm.class);
+        assertThat(result, hasSingleFailureContaining("unresolved type variable U"));
+    }
+
+    @RunWith(Theories.class)
+    public static class TypeVariableOnComponentOfArrayTypeOnTheoryParm {
+        @DataPoints
+        public static List<?>[][] items() {
+            return new List<?>[][]{
+                    new List<?>[]{Arrays.asList("foo")},
+                    new List<?>[]{Arrays.asList("bar")}
+            };
+        }
+
+        @Theory
+        public <U> void forItems(Collection<U>[] items) {
+        }
+    }
+
+    @Test
+    public void whereTypeVariableIsOnTheoryClass() {
+        PrintableResult result = testResult(TypeVariableOnTheoryClass.class);
+        assertThat(result, hasSingleFailureContaining("unresolved type variable T"));
+    }
+
+    @RunWith(Theories.class)
+    public static class TypeVariableOnTheoryClass<T> {
+        @DataPoint
+        public static String item = "bar";
+
+        @Theory
+        public void forItem(T item) {
+        }
+    }
+
+    @Test
+    public void whereTypeVariablesAbound() {
+        PrintableResult result = testResult(TypeVariablesAbound.class);
+        assertThat(result, failureCountIs(1));
+        assertThat(result, hasFailureContaining("unresolved type variable A"));
+        assertThat(result, hasFailureContaining("unresolved type variable B"));
+        assertThat(result, hasFailureContaining("unresolved type variable C"));
+        assertThat(result, hasFailureContaining("unresolved type variable D"));
+        assertThat(result, hasFailureContaining("unresolved type variable E"));
+        assertThat(result, hasFailureContaining("unresolved type variable F"));
+        assertThat(result, hasFailureContaining("unresolved type variable G"));
+    }
+
+    @RunWith(Theories.class)
+    public static class TypeVariablesAbound<A, B extends A, C extends Collection<B>> {
+        @Theory
+        public <D, E extends D, F, G> void forItem(A first, Collection<B> second,
+                Map<C, ? extends D> third, List<? super E> fourth, F[] fifth,
+                Collection<G>[] sixth) {
+        }
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/AllJUnit3CompatibilityTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/AllJUnit3CompatibilityTests.java
new file mode 100644
index 0000000..c85d01a
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/AllJUnit3CompatibilityTests.java
@@ -0,0 +1,21 @@
+package org.junit.tests.junit3compatibility;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AllTestsTest.class,
+        ClassRequestTest.class,
+        ForwardCompatibilityPrintingTest.class,
+        ForwardCompatibilityTest.class,
+        InitializationErrorForwardCompatibilityTest.class,
+        JUnit38ClassRunnerTest.class,
+        JUnit4TestAdapterTest.class,
+        OldTestClassAdaptingListenerTest.class,
+        OldTests.class,
+        SuiteMethodTest.class
+})
+public class AllJUnit3CompatibilityTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/AllTestsTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/AllTestsTest.java
new file mode 100644
index 0000000..3f4a7f4
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/AllTestsTest.java
@@ -0,0 +1,87 @@
+package org.junit.tests.junit3compatibility;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.RunWith;
+import org.junit.runners.AllTests;
+
+public class AllTestsTest {
+
+    private static boolean run;
+
+    public static class OneTest extends TestCase {
+        public void testSomething() {
+            run = true;
+        }
+    }
+
+    @RunWith(AllTests.class)
+    public static class All {
+        public static junit.framework.Test suite() {
+            TestSuite suite = new TestSuite();
+            suite.addTestSuite(OneTest.class);
+            return suite;
+        }
+    }
+
+    @org.junit.Test
+    public void ensureTestIsRun() {
+        JUnitCore runner = new JUnitCore();
+        run = false; // Have to explicitly set run here because the runner might independently run OneTest above
+        runner.run(All.class);
+        assertTrue(run);
+    }
+
+    @org.junit.Test
+    public void correctTestCount() throws Throwable {
+        AllTests tests = new AllTests(All.class);
+        assertEquals(1, tests.testCount());
+    }
+
+    @org.junit.Test
+    public void someUsefulDescription() throws Throwable {
+        AllTests tests = new AllTests(All.class);
+        assertThat(tests.getDescription().toString(), containsString("OneTest"));
+    }
+
+    public static class JUnit4Test {
+        @org.junit.Test
+        public void testSomething() {
+            run = true;
+        }
+    }
+
+    @RunWith(AllTests.class)
+    public static class AllJUnit4 {
+        public static junit.framework.Test suite() {
+            TestSuite suite = new TestSuite();
+            suite.addTest(new JUnit4TestAdapter(JUnit4Test.class));
+            return suite;
+        }
+    }
+
+    @org.junit.Test
+    public void correctTestCountAdapted() throws Throwable {
+        AllTests tests = new AllTests(AllJUnit4.class);
+        assertEquals(1, tests.testCount());
+    }
+
+    @RunWith(AllTests.class)
+    public static class BadSuiteMethod {
+        public static junit.framework.Test suite() {
+            throw new RuntimeException("can't construct");
+        }
+    }
+
+    @org.junit.Test(expected = RuntimeException.class)
+    public void exceptionThrownWhenSuiteIsBad() throws Throwable {
+        new AllTests(BadSuiteMethod.class);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/ClassRequestTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/ClassRequestTest.java
new file mode 100644
index 0000000..4c5c2ce
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/ClassRequestTest.java
@@ -0,0 +1,20 @@
+package org.junit.tests.junit3compatibility;
+
+import static org.junit.Assert.assertNull;
+
+import org.junit.Test;
+import org.junit.internal.builders.SuiteMethodBuilder;
+
+public class ClassRequestTest {
+    public static class PrivateSuiteMethod {
+        static junit.framework.Test suite() {
+            return null;
+        }
+    }
+
+    @Test
+    public void noSuiteMethodIfMethodPrivate() throws Throwable {
+        assertNull(new SuiteMethodBuilder()
+                .runnerForClass(PrivateSuiteMethod.class));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/ForwardCompatibilityPrintingTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/ForwardCompatibilityPrintingTest.java
new file mode 100644
index 0000000..cf40916
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/ForwardCompatibilityPrintingTest.java
@@ -0,0 +1,91 @@
+package org.junit.tests.junit3compatibility;
+
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+import junit.textui.ResultPrinter;
+import junit.textui.TestRunner;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ForwardCompatibilityPrintingTest extends TestCase {
+    static class TestResultPrinter extends ResultPrinter {
+        TestResultPrinter(PrintStream writer) {
+            super(writer);
+        }
+
+        /*
+           * Spoof printing time so the tests are deterministic
+           */
+        @Override
+        protected String elapsedTimeAsString(long runTime) {
+            return "0";
+        }
+    }
+
+    public void testError() {
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        TestRunner runner = new TestRunner(new TestResultPrinter(
+                new PrintStream(output)));
+
+        String expected = expected(new String[]{".E", "Time: 0",
+                "Errors here", "", "FAILURES!!!",
+                "Tests run: 1,  Failures: 0,  Errors: 1", ""});
+        ResultPrinter printer = new TestResultPrinter(new PrintStream(output)) {
+            @Override
+            public void printErrors(TestResult result) {
+                getWriter().println("Errors here");
+            }
+        };
+        runner.setPrinter(printer);
+        TestSuite suite = new TestSuite();
+        suite.addTest(new TestCase() {
+            @Override
+            public void runTest() throws Exception {
+                throw new Exception();
+            }
+        });
+        runner.doRun(suite);
+        assertEquals(expected, output.toString());
+    }
+
+    public static class ATest {
+        @Test
+        public void error() {
+            Assert.fail();
+        }
+    }
+
+    public void testErrorAdapted() {
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        TestRunner runner = new TestRunner(new TestResultPrinter(
+                new PrintStream(output)));
+
+        String expected = expected(new String[]{".E", "Time: 0",
+                "Errors here", "", "FAILURES!!!",
+                "Tests run: 1,  Failures: 0,  Errors: 1", ""});
+        ResultPrinter printer = new TestResultPrinter(new PrintStream(output)) {
+            @Override
+            public void printErrors(TestResult result) {
+                getWriter().println("Errors here");
+            }
+        };
+        runner.setPrinter(printer);
+        runner.doRun(new JUnit4TestAdapter(ATest.class));
+        assertEquals(expected, output.toString());
+    }
+
+    private String expected(String[] lines) {
+        OutputStream expected = new ByteArrayOutputStream();
+        PrintStream expectedWriter = new PrintStream(expected);
+        for (int i = 0; i < lines.length; i++) {
+            expectedWriter.println(lines[i]);
+        }
+        return expected.toString();
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/ForwardCompatibilityTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/ForwardCompatibilityTest.java
new file mode 100644
index 0000000..79539d1
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/ForwardCompatibilityTest.java
@@ -0,0 +1,254 @@
+package org.junit.tests.junit3compatibility;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.TestCase;
+import junit.framework.TestFailure;
+import junit.framework.TestListener;
+import junit.framework.TestResult;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runner.notification.RunNotifier;
+
+public class ForwardCompatibilityTest extends TestCase {
+    static String fLog;
+
+    public static class NewTest {
+        @Before
+        public void before() {
+            fLog += "before ";
+        }
+
+        @After
+        public void after() {
+            fLog += "after ";
+        }
+
+        @Test
+        public void test() {
+            fLog += "test ";
+        }
+    }
+
+    public void testCompatibility() {
+        fLog = "";
+        TestResult result = new TestResult();
+        junit.framework.Test adapter = new JUnit4TestAdapter(NewTest.class);
+        adapter.run(result);
+        assertEquals("before test after ", fLog);
+    }
+
+    public void testToString() {
+        JUnit4TestAdapter adapter = new JUnit4TestAdapter(NewTest.class);
+        junit.framework.Test test = adapter.getTests().get(0);
+        assertEquals(String.format("test(%s)", NewTest.class.getName()), test.toString());
+    }
+
+    public void testUseGlobalCache() {
+        JUnit4TestAdapter adapter1 = new JUnit4TestAdapter(NewTest.class);
+        JUnit4TestAdapter adapter2 = new JUnit4TestAdapter(NewTest.class);
+        assertSame(adapter1.getTests().get(0), adapter2.getTests().get(0));
+    }
+
+    static Exception exception = new Exception();
+
+    public static class ErrorTest {
+        @Test
+        public void error() throws Exception {
+            throw exception;
+        }
+    }
+
+    public void testException() {
+        TestResult result = new TestResult();
+        junit.framework.Test adapter = new JUnit4TestAdapter(ErrorTest.class);
+        adapter.run(result);
+        assertEquals(exception, result.errors().nextElement().thrownException());
+    }
+
+    public void testNotifyResult() {
+        JUnit4TestAdapter adapter = new JUnit4TestAdapter(ErrorTest.class);
+        TestResult result = new TestResult();
+        final StringBuffer log = new StringBuffer();
+        result.addListener(new TestListener() {
+
+            public void startTest(junit.framework.Test test) {
+                log.append(" start ").append(test);
+            }
+
+            public void endTest(junit.framework.Test test) {
+                log.append(" end ").append(test);
+            }
+
+            public void addFailure(junit.framework.Test test, AssertionFailedError t) {
+                log.append(" failure ").append(test);
+            }
+
+            public void addError(junit.framework.Test test, Throwable e) {
+                log.append(" error " + test);
+            }
+        });
+        adapter.run(result);
+        String testName = String.format("error(%s)", ErrorTest.class.getName());
+        assertEquals(String.format(" start %s error %s end %s", testName, testName, testName), log.toString());
+    }
+
+
+    public static class NoExceptionTest {
+        @Test(expected = Exception.class)
+        public void succeed() throws Exception {
+        }
+    }
+
+    public void testNoException() {
+        TestResult result = new TestResult();
+        junit.framework.Test adapter = new JUnit4TestAdapter(NoExceptionTest.class);
+        adapter.run(result);
+        assertFalse(result.wasSuccessful());
+    }
+
+    public static class ExpectedTest {
+        @Test(expected = Exception.class)
+        public void expected() throws Exception {
+            throw new Exception();
+        }
+    }
+
+    public void testExpected() {
+        TestResult result = new TestResult();
+        junit.framework.Test adapter = new JUnit4TestAdapter(ExpectedTest.class);
+        adapter.run(result);
+        assertTrue(result.wasSuccessful());
+    }
+
+    public static class UnExpectedExceptionTest {
+        @Test(expected = Exception.class)
+        public void expected() throws Exception {
+            throw new Error();
+        }
+    }
+
+    static String log;
+
+    public static class BeforeClassTest {
+        @BeforeClass
+        public static void beforeClass() {
+            log += "before class ";
+        }
+
+        @Before
+        public void before() {
+            log += "before ";
+        }
+
+        @Test
+        public void one() {
+            log += "test ";
+        }
+
+        @Test
+        public void two() {
+            log += "test ";
+        }
+
+        @After
+        public void after() {
+            log += "after ";
+        }
+
+        @AfterClass
+        public static void afterClass() {
+            log += "after class ";
+        }
+    }
+
+    public void testBeforeAndAfterClass() {
+        log = "";
+        TestResult result = new TestResult();
+        junit.framework.Test adapter = new JUnit4TestAdapter(BeforeClassTest.class);
+        adapter.run(result);
+        assertEquals("before class before test after before test after after class ", log);
+    }
+
+    public static class ExceptionInBeforeTest {
+        @Before
+        public void error() {
+            throw new Error();
+        }
+
+        @Test
+        public void nothing() {
+        }
+    }
+
+    public void testExceptionInBefore() {
+        TestResult result = new TestResult();
+        junit.framework.Test adapter = new JUnit4TestAdapter(ExceptionInBeforeTest.class);
+        adapter.run(result);
+        assertEquals(1, result.errorCount());
+    }
+
+    public static class InvalidMethodTest {
+        @BeforeClass
+        public void shouldBeStatic() {
+        }
+
+        @Test
+        public void aTest() {
+        }
+    }
+
+    public void testInvalidMethod() {
+        TestResult result = new TestResult();
+        junit.framework.Test adapter = new JUnit4TestAdapter(InvalidMethodTest.class);
+        adapter.run(result);
+        assertEquals(1, result.errorCount());
+        TestFailure failure = result.errors().nextElement();
+        assertTrue(failure.exceptionMessage().contains("Method shouldBeStatic() should be static"));
+    }
+
+    private static boolean wasRun = false;
+
+    public static class MarkerRunner extends Runner {
+        public MarkerRunner(Class<?> klass) {
+        }
+
+        @Override
+        public void run(RunNotifier notifier) {
+            wasRun = true;
+        }
+
+        @Override
+        public int testCount() {
+            return 0;
+        }
+
+        @Override
+        public Description getDescription() {
+            return Description.EMPTY;
+        }
+    }
+
+    @RunWith(MarkerRunner.class)
+    public static class NoTests {
+    }
+
+    public void testRunWithClass() {
+        wasRun = false;
+        TestResult result = new TestResult();
+        junit.framework.Test adapter = new JUnit4TestAdapter(NoTests.class);
+        adapter.run(result);
+        assertTrue(wasRun);
+    }
+
+    public void testToStringSuite() {
+        junit.framework.Test adapter = new JUnit4TestAdapter(NoTests.class);
+        assertEquals(NoTests.class.getName(), adapter.toString());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/InitializationErrorForwardCompatibilityTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/InitializationErrorForwardCompatibilityTest.java
new file mode 100644
index 0000000..ec49701
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/InitializationErrorForwardCompatibilityTest.java
@@ -0,0 +1,102 @@
+package org.junit.tests.junit3compatibility;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.TestListener;
+import junit.framework.TestResult;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+
+public class InitializationErrorForwardCompatibilityTest {
+    public static class CantInitialize extends Runner {
+        private static final String UNIQUE_ERROR_MESSAGE = "Unique error message";
+
+        public CantInitialize(Class<?> klass) throws Exception {
+            throw new Exception(UNIQUE_ERROR_MESSAGE);
+        }
+
+        @Override
+        public Description getDescription() {
+            return Description.EMPTY;
+        }
+
+        @Override
+        public void run(RunNotifier notifier) {
+        }
+    }
+
+    @RunWith(CantInitialize.class)
+    public static class CantInitializeTests {
+    }
+
+    private JUnit4TestAdapter fAdapter;
+
+    @Before
+    public void createAdapter() {
+        fAdapter = new JUnit4TestAdapter(
+                CantInitializeTests.class);
+    }
+
+    @Test
+    public void initializationErrorsShowUpAsWarnings() {
+        assertEquals(1, fAdapter.getTests().size());
+    }
+
+    @Test
+    public void initializationErrorsAreThrownAtRuntime() {
+        TestResult result = new TestResult();
+        fAdapter.run(result);
+        assertEquals(1, result.errorCount());
+        assertEquals(CantInitialize.UNIQUE_ERROR_MESSAGE, result.errors()
+                .nextElement().exceptionMessage());
+    }
+
+    private final class ErrorRememberingListener implements TestListener {
+        private junit.framework.Test fError;
+
+        public void addError(junit.framework.Test test, Throwable e) {
+            fError = test;
+        }
+
+        public void addFailure(junit.framework.Test test,
+                AssertionFailedError t) {
+        }
+
+        public void endTest(junit.framework.Test test) {
+        }
+
+        public void startTest(junit.framework.Test test) {
+        }
+
+        public junit.framework.Test getError() {
+            return fError;
+        }
+    }
+
+    @Test
+    public void generatedErrorTestsMatchUp() {
+        junit.framework.Test shouldFail = fAdapter.getTests().get(0);
+        TestResult result = new TestResult();
+        ErrorRememberingListener listener = new ErrorRememberingListener();
+        result.addListener(listener);
+        fAdapter.run(result);
+        assertNotNull(listener.getError());
+        assertTrue(shouldFail == listener.getError());
+    }
+
+    public static class InitializesWithError extends BlockJUnit4ClassRunner {
+        public InitializesWithError(Class<?> klass) throws Exception {
+            super(klass);
+            throw new Exception();
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/JUnit38ClassRunnerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/JUnit38ClassRunnerTest.java
new file mode 100644
index 0000000..429bde6
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/JUnit38ClassRunnerTest.java
@@ -0,0 +1,155 @@
+package org.junit.tests.junit3compatibility;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertNotNull;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import junit.extensions.TestDecorator;
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.internal.runners.JUnit38ClassRunner;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.NoTestsRemainException;
+
+public class JUnit38ClassRunnerTest {
+    public static class MyTest extends TestCase {
+        public void testA() {
+
+        }
+    }
+
+    @Test
+    public void plansDecoratorCorrectly() {
+        JUnit38ClassRunner runner = new JUnit38ClassRunner(new TestDecorator(new TestSuite(MyTest.class)));
+        assertEquals(1, runner.testCount());
+    }
+
+    public static class AnnotatedTest {
+        @Test
+        public void foo() {
+            Assert.fail();
+        }
+    }
+
+    @Test
+    public void canUnadaptAnAdapter() {
+        JUnit38ClassRunner runner = new JUnit38ClassRunner(new JUnit4TestAdapter(AnnotatedTest.class));
+        Result result = new JUnitCore().run(runner);
+        Failure failure = result.getFailures().get(0);
+        assertEquals(Description.createTestDescription(AnnotatedTest.class, "foo"), failure.getDescription());
+    }
+
+    static int count;
+
+    public static class OneTest extends TestCase {
+        public void testOne() {
+        }
+    }
+
+    @Test
+    public void testListener() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        RunListener listener = new RunListener() {
+            @Override
+            public void testStarted(Description description) {
+                assertEquals(Description.createTestDescription(OneTest.class, "testOne"),
+                        description);
+                count++;
+            }
+        };
+
+        runner.addListener(listener);
+        count = 0;
+        Result result = runner.run(OneTest.class);
+        assertEquals(1, count);
+        assertEquals(1, result.getRunCount());
+    }
+
+    public static class ClassWithInvalidMethod extends TestCase {
+        @SuppressWarnings("unused")
+        private void testInvalid() {
+        }
+    }
+
+    @Test
+    public void invalidTestMethodReportedCorrectly() {
+        Result result = JUnitCore.runClasses(ClassWithInvalidMethod.class);
+        Failure failure = result.getFailures().get(0);
+        assertEquals("warning", failure.getDescription().getMethodName());
+        assertEquals("junit.framework.TestSuite$1", failure.getDescription().getClassName());
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    public static @interface MyAnnotation {
+    }
+
+    public static class JUnit3ClassWithAnnotatedMethod extends TestCase {
+        @MyAnnotation
+        public void testAnnotated() {
+        }
+
+        public void testNotAnnotated() {
+        }
+    }
+
+    public static class DerivedAnnotatedMethod extends JUnit3ClassWithAnnotatedMethod {
+    }
+
+    @Test
+    public void getDescriptionWithAnnotation() {
+        JUnit38ClassRunner runner = new JUnit38ClassRunner(JUnit3ClassWithAnnotatedMethod.class);
+        assertAnnotationFiltering(runner);
+    }
+    
+    @Test
+    public void getDescriptionWithAnnotationInSuper() {
+        JUnit38ClassRunner runner = new JUnit38ClassRunner(DerivedAnnotatedMethod.class);
+        assertAnnotationFiltering(runner);
+    }
+
+    private void assertAnnotationFiltering(JUnit38ClassRunner runner) {
+        Description d = runner.getDescription();
+        assertEquals(2, d.testCount());
+        for (Description methodDesc : d.getChildren()) {
+            if (methodDesc.getMethodName().equals("testAnnotated")) {
+                assertNotNull(methodDesc.getAnnotation(MyAnnotation.class));
+            } else {
+                assertNull(methodDesc.getAnnotation(MyAnnotation.class));
+            }
+        }
+    }
+
+    public static class RejectAllTestsFilter extends Filter {
+        @Override
+        public boolean shouldRun(Description description) {
+            return description.isSuite();
+        }
+
+        @Override
+        public String describe() {
+            return "filter all";
+        }
+    }
+
+    /**
+     * Test that NoTestsRemainException is thrown when all methods have been filtered.
+     */
+    @Test(expected = NoTestsRemainException.class) 
+    public void filterNoTestsRemain() throws NoTestsRemainException {
+        JUnit38ClassRunner runner = new JUnit38ClassRunner(OneTest.class);
+        runner.filter(new RejectAllTestsFilter());  
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/JUnit4TestAdapterTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/JUnit4TestAdapterTest.java
new file mode 100644
index 0000000..8d20f33
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/JUnit4TestAdapterTest.java
@@ -0,0 +1,82 @@
+package org.junit.tests.junit3compatibility;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Collections;
+
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+public class JUnit4TestAdapterTest {
+
+    private static void doTest(Class<?> clazz) {
+        // JUnit 4 runner:
+        Result result = JUnitCore.runClasses(clazz);
+        assertEquals(1, result.getRunCount());
+        assertEquals(0, result.getFailureCount());
+        assertEquals(0, result.getIgnoreCount());
+
+        // JUnit 3 runner:
+        TestResult testResult = new TestResult();
+        new JUnit4TestAdapter(clazz).run(testResult);
+        assertEquals(1, testResult.runCount());
+        assertEquals(0, testResult.failureCount());
+        assertEquals(Collections.emptyList(), Collections.list(testResult.errors()));
+    }
+
+    public static class Test4 {
+        @Test
+        public void pass() throws Exception {
+            //pass
+        }
+    }
+
+    @RunWith(Suite.class)
+    @Suite.SuiteClasses(Test4.class)
+    public static class TestSuiteFor4 {
+    }
+
+    @Test
+    public void testJUnit4Suite() {
+        doTest(TestSuiteFor4.class);
+    }
+
+    public static class Test3 extends TestCase {
+        public void testPass() throws Exception {
+            //pass
+        }
+    }
+
+    @RunWith(Suite.class)
+    @Suite.SuiteClasses(Test3.class)
+    public static class TestSuiteFor3 {
+    }
+
+    @Test
+    public void testJUnit3Suite() {
+        doTest(TestSuiteFor3.class);
+    }
+
+    public static class TestSuite3 {
+        public static junit.framework.Test suite() {
+            return new TestSuite(Test3.class);
+        }
+    }
+
+    @RunWith(Suite.class)
+    @Suite.SuiteClasses(TestSuite3.class)
+    public static class TestSuite4ForTestSuite3 {
+    }
+
+    @Test
+    public void testJUnit4SuiteThatContainsJUnit3SuiteClass() {
+        doTest(TestSuite4ForTestSuite3.class);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/OldTestClassAdaptingListenerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/OldTestClassAdaptingListenerTest.java
new file mode 100644
index 0000000..9822b14
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/OldTestClassAdaptingListenerTest.java
@@ -0,0 +1,28 @@
+package org.junit.tests.junit3compatibility;
+
+import static org.junit.Assert.assertEquals;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
+import junit.framework.TestListener;
+import org.junit.Test;
+import org.junit.internal.runners.JUnit38ClassRunner;
+import org.junit.runner.Result;
+import org.junit.runner.notification.RunListener;
+import org.junit.runner.notification.RunNotifier;
+
+public class OldTestClassAdaptingListenerTest {
+    @Test
+    public void addFailureDelegatesToNotifier() {
+        Result result = new Result();
+        RunListener listener = result.createListener();
+        RunNotifier notifier = new RunNotifier();
+        notifier.addFirstListener(listener);
+        TestCase testCase = new TestCase() {
+        };
+        TestListener adaptingListener = new JUnit38ClassRunner(testCase)
+                .createAdaptingListener(notifier);
+        adaptingListener.addFailure(testCase, new AssertionFailedError());
+        assertEquals(1, result.getFailureCount());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/OldTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/OldTests.java
new file mode 100644
index 0000000..bee32f5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/OldTests.java
@@ -0,0 +1,12 @@
+package org.junit.tests.junit3compatibility;
+
+import junit.framework.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.AllTests;
+
+@RunWith(AllTests.class)
+public class OldTests {
+    public static Test suite() {
+        return junit.tests.AllTests.suite();
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/SuiteMethodTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/SuiteMethodTest.java
new file mode 100644
index 0000000..55c1cd1
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/junit3compatibility/SuiteMethodTest.java
@@ -0,0 +1,134 @@
+package org.junit.tests.junit3compatibility;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+
+public class SuiteMethodTest {
+    public static boolean wasRun;
+
+    public static class OldTest extends TestCase {
+        public OldTest(String name) {
+            super(name);
+        }
+
+        public static junit.framework.Test suite() {
+            TestSuite suite = new TestSuite();
+            suite.addTest(new OldTest("notObviouslyATest"));
+            return suite;
+        }
+
+        public void notObviouslyATest() {
+            wasRun = true;
+        }
+    }
+
+    @Test
+    public void makeSureSuiteIsCalled() {
+        wasRun = false;
+        JUnitCore.runClasses(OldTest.class);
+        assertTrue(wasRun);
+    }
+
+    public static class NewTest {
+        @Test
+        public void sample() {
+            wasRun = true;
+        }
+
+        public static junit.framework.Test suite() {
+            return new JUnit4TestAdapter(NewTest.class);
+        }
+    }
+
+    @Test
+    public void makeSureSuiteWorksWithJUnit4Classes() {
+        wasRun = false;
+        JUnitCore.runClasses(NewTest.class);
+        assertTrue(wasRun);
+    }
+
+
+    public static class CompatibilityTest {
+        @Ignore
+        @Test
+        public void ignored() {
+        }
+
+        public static junit.framework.Test suite() {
+            return new JUnit4TestAdapter(CompatibilityTest.class);
+        }
+    }
+
+    // when executing as JUnit 3, ignored tests are stripped out before execution
+    @Test
+    public void descriptionAndRunNotificationsAreConsistent() {
+        Result result = JUnitCore.runClasses(CompatibilityTest.class);
+        assertEquals(0, result.getIgnoreCount());
+
+        Description description = Request.aClass(CompatibilityTest.class).getRunner().getDescription();
+        assertEquals(0, description.getChildren().size());
+    }
+
+    public static class NewTestSuiteFails {
+        @Test
+        public void sample() {
+            wasRun = true;
+        }
+
+        public static junit.framework.Test suite() {
+            fail("called with JUnit 4 runner");
+            return null;
+        }
+    }
+
+    @Test
+    public void suiteIsUsedWithJUnit4Classes() {
+        wasRun = false;
+        Result result = JUnitCore.runClasses(NewTestSuiteFails.class);
+        assertEquals(1, result.getFailureCount());
+        assertFalse(wasRun);
+    }
+
+    public static class NewTestSuiteNotUsed {
+        private static boolean wasIgnoredRun;
+
+        @Test
+        public void sample() {
+            wasRun = true;
+        }
+
+        @Ignore
+        @Test
+        public void ignore() {
+            wasIgnoredRun = true;
+        }
+
+        public static junit.framework.Test suite() {
+            return new JUnit4TestAdapter(NewTestSuiteNotUsed.class);
+        }
+    }
+
+    @Test
+    public void makeSureSuiteNotUsedWithJUnit4Classes2() {
+        wasRun = false;
+        NewTestSuiteNotUsed.wasIgnoredRun = false;
+        Result res = JUnitCore.runClasses(NewTestSuiteNotUsed.class);
+        assertTrue(wasRun);
+        assertFalse(NewTestSuiteNotUsed.wasIgnoredRun);
+        assertEquals(0, res.getFailureCount());
+        assertEquals(1, res.getRunCount());
+        assertEquals(0, res.getIgnoreCount());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/AllListeningTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/AllListeningTests.java
new file mode 100644
index 0000000..cadbd2e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/AllListeningTests.java
@@ -0,0 +1,16 @@
+package org.junit.tests.listening;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        ListenerTest.class,
+        RunnerTest.class,
+        TestListenerTest.class,
+        TextListenerTest.class,
+        UserStopTest.class
+})
+public class AllListeningTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/ListenerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/ListenerTest.java
new file mode 100644
index 0000000..b300339
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/ListenerTest.java
@@ -0,0 +1,38 @@
+package org.junit.tests.listening;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.notification.RunListener;
+
+public class ListenerTest {
+    private static String log;
+
+    public static class OneTest {
+        @Test
+        public void nothing() {
+        }
+    }
+
+    @Test
+    public void notifyListenersInTheOrderInWhichTheyAreAdded() {
+        JUnitCore core = new JUnitCore();
+        log = "";
+        core.addListener(new RunListener() {
+            @Override
+            public void testRunStarted(Description description) throws Exception {
+                log += "first ";
+            }
+        });
+        core.addListener(new RunListener() {
+            @Override
+            public void testRunStarted(Description description) throws Exception {
+                log += "second ";
+            }
+        });
+        core.run(OneTest.class);
+        assertEquals("first second ", log);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/RunnerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/RunnerTest.java
new file mode 100644
index 0000000..cd12c35
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/RunnerTest.java
@@ -0,0 +1,75 @@
+package org.junit.tests.listening;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import junit.framework.TestCase;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.notification.RunListener;
+
+public class RunnerTest {
+
+    private boolean wasRun;
+
+    public class MyListener extends RunListener {
+
+        int testCount;
+
+        @Override
+        public void testRunStarted(Description description) {
+            this.testCount = description.testCount();
+        }
+    }
+
+    public static class Example {
+        @Test
+        public void empty() {
+        }
+    }
+
+    @Test
+    public void newTestCount() {
+        JUnitCore runner = new JUnitCore();
+        MyListener listener = new MyListener();
+        runner.addListener(listener);
+        runner.run(Example.class);
+        assertEquals(1, listener.testCount);
+    }
+
+    public static class ExampleTest extends TestCase {
+        public void testEmpty() {
+        }
+    }
+
+    @Test
+    public void oldTestCount() {
+        JUnitCore runner = new JUnitCore();
+        MyListener listener = new MyListener();
+        runner.addListener(listener);
+        runner.run(ExampleTest.class);
+        assertEquals(1, listener.testCount);
+    }
+
+    public static class NewExample {
+        @Test
+        public void empty() {
+        }
+    }
+
+    @Test
+    public void testFinished() {
+        JUnitCore runner = new JUnitCore();
+        wasRun = false;
+        RunListener listener = new MyListener() {
+            @Override
+            public void testFinished(Description description) {
+                wasRun = true;
+            }
+        };
+        runner.addListener(listener);
+        runner.run(NewExample.class);
+        assertTrue(wasRun);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/TestListenerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/TestListenerTest.java
new file mode 100644
index 0000000..693c15e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/TestListenerTest.java
@@ -0,0 +1,65 @@
+package org.junit.tests.listening;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+
+public class TestListenerTest {
+
+    int count;
+
+    class ErrorListener extends RunListener {
+        @Override
+        public void testRunStarted(Description description) throws Exception {
+            throw new Error();
+        }
+    }
+
+    public static class OneTest {
+        @Test
+        public void nothing() {
+        }
+    }
+
+    @Test(expected = Error.class)
+    public void failingListener() {
+        JUnitCore runner = new JUnitCore();
+        runner.addListener(new ErrorListener());
+        runner.run(OneTest.class);
+    }
+
+    class ExceptionListener extends ErrorListener {
+        @Override
+        public void testRunStarted(Description description) throws Exception {
+            count++;
+            throw new Exception();
+        }
+    }
+
+    @Test
+    public void reportsFailureOfListener() {
+        JUnitCore core = new JUnitCore();
+        core.addListener(new ExceptionListener());
+
+        count = 0;
+        Result result = core.run(OneTest.class);
+        assertEquals(1, count);
+        assertEquals(1, result.getFailureCount());
+        Failure testFailure = result.getFailures().get(0);
+        assertEquals(Description.TEST_MECHANISM, testFailure.getDescription());
+    }
+
+    @Test
+    public void freshResultEachTime() {
+        JUnitCore core = new JUnitCore();
+        Result first = core.run(OneTest.class);
+        Result second = core.run(OneTest.class);
+        assertNotSame(first, second);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/TextListenerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/TextListenerTest.java
new file mode 100644
index 0000000..0cb1aff
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/TextListenerTest.java
@@ -0,0 +1,73 @@
+package org.junit.tests.listening;
+
+import static org.hamcrest.core.IsNot.not;
+import static org.hamcrest.core.StringContains.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+import junit.framework.TestCase;
+import org.junit.Test;
+import org.junit.internal.TextListener;
+import org.junit.runner.JUnitCore;
+import org.junit.tests.TestSystem;
+
+public class TextListenerTest extends TestCase {
+
+    private JUnitCore runner;
+    private OutputStream results;
+
+    @Override
+    public void setUp() {
+        runner = new JUnitCore();
+        TestSystem system = new TestSystem();
+        results = system.outContents();
+        runner.addListener(new TextListener(system));
+    }
+
+    public static class OneTest {
+        @Test
+        public void one() {
+        }
+    }
+
+    public void testSuccess() throws Exception {
+        runner.run(OneTest.class);
+        assertTrue(results.toString().startsWith(convert(".\nTime: ")));
+        assertTrue(results.toString().endsWith(convert("\n\nOK (1 test)\n\n")));
+    }
+
+    public static class ErrorTest {
+        @Test
+        public void error() throws Exception {
+            throw new Exception();
+        }
+    }
+
+    public void testError() throws Exception {
+        runner.run(ErrorTest.class);
+        assertTrue(results.toString().startsWith(convert(".E\nTime: ")));
+        assertTrue(results.toString().indexOf(convert("\nThere was 1 failure:\n1) error(org.junit.tests.listening.TextListenerTest$ErrorTest)\njava.lang.Exception")) != -1);
+    }
+
+    public static class Time {
+        @Test
+        public void time() {
+        }
+    }
+
+    public void testTime() {
+        runner.run(Time.class);
+        assertThat(results.toString(), containsString("Time: "));
+        assertThat(results.toString(), not(containsString(convert("Time: \n"))));
+    }
+
+    private String convert(String string) {
+        OutputStream resultsStream = new ByteArrayOutputStream();
+        PrintStream writer = new PrintStream(resultsStream);
+        writer.println();
+        return string.replace("\n", resultsStream.toString());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/UserStopTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/UserStopTest.java
new file mode 100644
index 0000000..1233cce
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/listening/UserStopTest.java
@@ -0,0 +1,33 @@
+package org.junit.tests.listening;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.Request;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runner.notification.StoppedByUserException;
+
+public class UserStopTest {
+    private RunNotifier fNotifier;
+
+    @Before
+    public void createNotifier() {
+        fNotifier = new RunNotifier();
+        fNotifier.pleaseStop();
+    }
+
+    @Test(expected = StoppedByUserException.class)
+    public void userStop() {
+        fNotifier.fireTestStarted(null);
+    }
+
+    public static class OneTest {
+        @Test
+        public void foo() {
+        }
+    }
+
+    @Test(expected = StoppedByUserException.class)
+    public void stopClassRunner() throws Exception {
+        Request.aClass(OneTest.class).getRunner().run(fNotifier);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/AllManipulationTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/AllManipulationTests.java
new file mode 100644
index 0000000..5989e1b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/AllManipulationTests.java
@@ -0,0 +1,17 @@
+package org.junit.tests.manipulation;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        FilterableTest.class,
+        FilterTest.class,
+        OrderableTest.class,
+        OrderWithTest.class,
+        SingleMethodTest.class,
+        SortableTest.class
+})
+public class AllManipulationTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/AlphanumericOrdering.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/AlphanumericOrdering.java
new file mode 100644
index 0000000..ff1a513
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/AlphanumericOrdering.java
@@ -0,0 +1,15 @@
+package org.junit.tests.manipulation;
+
+import org.junit.runner.manipulation.Ordering;
+
+/**
+ * An ordering that orders tests alphanumerically by test name.
+ */
+public final class AlphanumericOrdering implements Ordering.Factory {
+    public static final ComparatorBasedOrdering INSTANCE = new ComparatorBasedOrdering(
+            Comparators.alphanumeric());
+
+    public Ordering create(Ordering.Context context) {
+        return INSTANCE;
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/ComparatorBasedOrdering.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/ComparatorBasedOrdering.java
new file mode 100644
index 0000000..6eff4a9
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/ComparatorBasedOrdering.java
@@ -0,0 +1,28 @@
+package org.junit.tests.manipulation;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.junit.runner.Description;
+import org.junit.runner.manipulation.Ordering;
+
+/**
+ * An ordering that internally uses a {@link Comparator}.
+ */
+class ComparatorBasedOrdering extends Ordering {
+    private final Comparator<Description> comparator;
+
+    protected ComparatorBasedOrdering(Comparator<Description> comparator) {
+        this.comparator = comparator;
+    }
+
+    @Override
+    protected List<Description> orderItems(Collection<Description> descriptions) {
+        List<Description> ordered = new ArrayList<Description>(descriptions);
+        Collections.sort(ordered, comparator);
+        return ordered;
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/Comparators.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/Comparators.java
new file mode 100644
index 0000000..8c61e89
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/Comparators.java
@@ -0,0 +1,19 @@
+package org.junit.tests.manipulation;
+
+import java.util.Comparator;
+
+import org.junit.runner.Description;
+import org.junit.runner.manipulation.Alphanumeric;
+
+/**
+ * Factory and utility methods for creating {@link Comparator} instances for tests.
+ */
+class Comparators {
+    private static final Comparator<Description> ALPHANUMERIC  = new Alphanumeric();
+
+    private Comparators() {}
+ 
+    public static Comparator<Description> alphanumeric() {
+        return ALPHANUMERIC;
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/FilterTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/FilterTest.java
new file mode 100644
index 0000000..a9c0136
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/FilterTest.java
@@ -0,0 +1,50 @@
+package org.junit.tests.manipulation;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.manipulation.Filter;
+
+public class FilterTest {
+    public static class NamedFilter extends Filter {
+        private final String fName;
+
+        public NamedFilter(String name) {
+            fName = name;
+        }
+
+        @Override
+        public boolean shouldRun(Description description) {
+            return false;
+        }
+
+        @Override
+        public String describe() {
+            return fName;
+        }
+    }
+
+    @Test
+    public void intersectionText() {
+        NamedFilter a = new NamedFilter("a");
+        NamedFilter b = new NamedFilter("b");
+        assertEquals("a and b", a.intersect(b).describe());
+        assertEquals("b and a", b.intersect(a).describe());
+    }
+
+    @Test
+    public void intersectSelf() {
+        NamedFilter a = new NamedFilter("a");
+        assertSame(a, a.intersect(a));
+    }
+
+    @Test
+    public void intersectAll() {
+        NamedFilter a = new NamedFilter("a");
+        assertSame(a, a.intersect(Filter.ALL));
+        assertSame(a, Filter.ALL.intersect(a));
+        assertSame(Filter.ALL, Filter.ALL.intersect(Filter.ALL));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/FilterableTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/FilterableTest.java
new file mode 100644
index 0000000..f1f5060
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/FilterableTest.java
@@ -0,0 +1,62 @@
+package org.junit.tests.manipulation;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+public class FilterableTest {
+    public static class FilteredRunner extends Parameterized {
+        public FilteredRunner(Class<?> klass) throws Throwable {
+            super(klass);
+            filter(new Filter() {
+
+                @Override
+                public boolean shouldRun(Description description) {
+                    return !description.getDisplayName().contains("skip");
+                }
+
+                @Override
+                public String describe() {
+                    return "skip methods containing the word 'skip'";
+                }
+            });
+        }
+    }
+
+    @RunWith(FilteredRunner.class)
+    public static class FilteredTest {
+        @Parameters
+        public static List<Object[]> parameters() {
+            return Arrays.asList(new Object[]{3}, new Object[]{4});
+        }
+
+        public FilteredTest(int x) {
+        }
+
+        @Test
+        public void skipThis() {
+            Assert.fail();
+        }
+
+        @Test
+        public void runThis() {
+        }
+    }
+
+    @Test
+    public void testFilterInRunnerConstructor() {
+        Result result = JUnitCore.runClasses(FilteredTest.class);
+        assertTrue(result.wasSuccessful());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/OrderWithTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/OrderWithTest.java
new file mode 100644
index 0000000..bfefeb3
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/OrderWithTest.java
@@ -0,0 +1,268 @@
+package org.junit.tests.manipulation;
+
+import static org.junit.Assert.assertEquals;
+import junit.framework.JUnit4TestAdapter;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.OrderWith;
+import org.junit.runner.Request;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Alphanumeric;
+import org.junit.runner.notification.RunNotifier;
+
+@RunWith(Enclosed.class)
+public class OrderWithTest {
+ 
+    public static class TestClassRunnerIsOrderableViaOrderWith {
+        private static String log = "";
+
+        public static class Unordered {
+            @Test
+            public void a() {
+                log += "a";
+            }
+
+            @Test
+            public void b() {
+                log += "b";
+            }
+
+            @Test
+            public void c() {
+                log += "c";
+            }
+        }
+
+        @OrderWith(AlphanumericOrdering.class)
+        public static class OrderedAlphanumerically extends Unordered {
+        }
+
+        @OrderWith(ReverseAlphanumericOrdering.class)
+        public static class OrderedReverseAlphanumerically extends Unordered {
+        }
+
+        @Before
+        public void resetLog() {
+            log = "";
+        }
+
+        @Test
+        public void orderingForwardWorksOnTestClassRunner() {
+            Request forward = Request.aClass(OrderedAlphanumerically.class);
+
+            new JUnitCore().run(forward);
+            assertEquals("abc", log);
+        }
+
+        @Test
+        public void orderingBackwardWorksOnTestClassRunner() {
+            Request backward = Request.aClass(OrderedReverseAlphanumerically.class);
+
+            new JUnitCore().run(backward);
+            assertEquals("cba", log);
+        }
+
+        @RunWith(Enclosed.class)
+        public static class UnorderedSuite {
+            public static class A {
+                @Test
+                public void a() {
+                    log += "Aa";
+                }
+
+                @Test
+                public void b() {
+                    log += "Ab";
+                }
+
+                @Test
+                public void c() {
+                    log += "Ac";
+                }
+            }
+
+            public static class B {
+                @Test
+                public void a() {
+                    log += "Ba";
+                }
+
+                @Test
+                public void b() {
+                    log += "Bb";
+                }
+
+                @Test
+                public void c() {
+                    log += "Bc";
+                }
+            }
+        }
+
+        @OrderWith(AlphanumericOrdering.class)
+        public static class SuiteOrderedAlphanumerically extends UnorderedSuite {
+        }
+
+        @OrderWith(ReverseAlphanumericOrdering.class)
+        public static class SuiteOrderedReverseAlphanumerically extends UnorderedSuite {
+        }
+
+        @Test
+        public void orderingForwardWorksOnSuite() {
+            Request forward = Request.aClass(SuiteOrderedAlphanumerically.class);
+
+            new JUnitCore().run(forward);
+            assertEquals("AaAbAcBaBbBc", log);
+        }
+
+        @Test
+        public void orderingBackwardWorksOnSuite() {
+            Request backward = Request.aClass(SuiteOrderedReverseAlphanumerically.class);
+
+            new JUnitCore().run(backward);
+            assertEquals("BcBbBaAcAbAa", log);
+        }
+    }
+
+    public static class TestClassRunnerIsSortableViaOrderWith {
+        private static String log = "";
+
+        public static class Unordered {
+            @Test
+            public void a() {
+                log += "a";
+            }
+
+            @Test
+            public void b() {
+                log += "b";
+            }
+
+            @Test
+            public void c() {
+                log += "c";
+            }
+        }
+
+        @Before
+        public void resetLog() {
+            log = "";
+        }
+
+        @OrderWith(Alphanumeric.class)
+        public static class SortedAlphanumerically extends Unordered {
+        }
+
+        @OrderWith(ReverseAlphanumericSorter.class)
+        public static class SortedReverseAlphanumerically extends Unordered {
+        }
+ 
+        @Test
+        public void sortingForwardWorksOnTestClassRunner() {
+            Request forward = Request.aClass(SortedAlphanumerically.class);
+
+            new JUnitCore().run(forward);
+            assertEquals("abc", log);
+        }
+
+        @Test
+        public void sortingBackwardWorksOnTestClassRunner() {
+            Request backward = Request.aClass(SortedReverseAlphanumerically.class);
+
+            new JUnitCore().run(backward);
+            assertEquals("cba", log);
+        }
+    }
+
+    public static class TestClassRunnerIsOrderableWithSuiteMethod {
+        private static String log = "";
+
+        public static class Unordered {
+            @Test
+            public void a() {
+                log += "a";
+            }
+
+            @Test
+            public void b() {
+                log += "b";
+            }
+
+            @Test
+            public void c() {
+                log += "c";
+            }
+        }
+        
+        @OrderWith(AlphanumericOrdering.class)
+        public static class OrderedAlphanumerically extends Unordered {
+ 
+            public static junit.framework.Test suite() {
+                return new JUnit4TestAdapter(OrderedAlphanumerically.class);
+            }
+        }
+
+        @OrderWith(ReverseAlphanumericOrdering.class)
+        public static class OrderedReverseAlphanumerically extends Unordered {
+
+            public static junit.framework.Test suite() {
+                return new JUnit4TestAdapter(OrderedReverseAlphanumerically.class);
+            }
+        }
+
+        @Before
+        public void resetLog() {
+            log = "";
+        }
+
+        @Test
+        public void orderingForwardWorksOnTestClassRunner() {
+            Request forward = Request.aClass(OrderedAlphanumerically.class);
+
+            new JUnitCore().run(forward);
+            assertEquals("abc", log);
+        }
+
+        @Test
+        public void orderingBackwardWorksOnTestClassRunner() {
+            Request backward = Request.aClass(OrderedReverseAlphanumerically.class);
+
+            new JUnitCore().run(backward);
+            assertEquals("cba", log);
+        }
+    }
+
+    public static class UnOrderableRunnersAreHandledWithoutCrashing {
+        public static class UnOrderableRunner extends Runner {
+            public UnOrderableRunner(Class<?> klass) {
+            }
+
+            @Override
+            public Description getDescription() {
+                return Description.EMPTY;
+            }
+
+            @Override
+            public void run(RunNotifier notifier) {
+            }
+        }
+
+        @RunWith(UnOrderableRunner.class)
+        public static class UnOrderable {
+            @Test
+            public void a() {
+            }
+        }
+
+        @Test
+        public void unOrderablesAreHandledWithoutCrashing() {
+            Request unordered = Request.aClass(UnOrderable.class).orderWith(
+                    AlphanumericOrdering.INSTANCE);
+            new JUnitCore().run(unordered);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/OrderableTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/OrderableTest.java
new file mode 100644
index 0000000..4adfac2
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/OrderableTest.java
@@ -0,0 +1,301 @@
+package org.junit.tests.manipulation;
+
+import static org.junit.Assert.assertEquals;
+import junit.framework.JUnit4TestAdapter;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Orderer;
+import org.junit.runner.manipulation.InvalidOrderingException;
+import org.junit.runner.manipulation.Orderable;
+import org.junit.runner.manipulation.Sorter;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.MethodSorters;
+
+@RunWith(Enclosed.class)
+public class OrderableTest {
+ 
+    public static class TestClassRunnerIsOrderable {
+        private static String log = "";
+
+        public static class OrderMe {
+            @Test
+            public void a() {
+                log += "a";
+            }
+
+            @Test
+            public void b() {
+                log += "b";
+            }
+
+            @Test
+            public void c() {
+                log += "c";
+            }
+        }
+
+        @FixMethodOrder(MethodSorters.NAME_ASCENDING)
+        public static class DoNotOrderMe {
+            @Test
+            public void a() {
+                log += "a";
+            }
+
+            @Test
+            public void b() {
+                log += "b";
+            }
+
+            @Test
+            public void c() {
+                log += "c";
+            }
+        }
+
+        @Before
+        public void resetLog() {
+            log = "";
+        }
+
+        @Test
+        public void orderingForwardWorksOnTestClassRunner() {
+            Request forward = Request.aClass(OrderMe.class).orderWith(
+                    AlphanumericOrdering.INSTANCE);
+
+            new JUnitCore().run(forward);
+            assertEquals("abc", log);
+        }
+
+        @Test
+        public void orderingBackwardWorksOnTestClassRunner() {
+            Request backward = Request.aClass(OrderMe.class).orderWith(
+                    new ReverseAlphanumericOrdering());
+
+            new JUnitCore().run(backward);
+            assertEquals("cba", log);
+        }
+        
+        @Test
+        public void orderingBackwardDoesNothingOnTestClassRunnerWithFixMethodOrder() {
+            Request backward = Request.aClass(DoNotOrderMe.class).orderWith(
+                    new ReverseAlphanumericOrdering());
+
+            new JUnitCore().run(backward);
+            assertEquals("abc", log);
+        }
+
+        @RunWith(Enclosed.class)
+        public static class Enclosing {
+            public static class A {
+                @Test
+                public void a() {
+                    log += "Aa";
+                }
+
+                @Test
+                public void b() {
+                    log += "Ab";
+                }
+
+                @Test
+                public void c() {
+                    log += "Ac";
+                }
+            }
+
+            public static class B {
+                @Test
+                public void a() {
+                    log += "Ba";
+                }
+
+                @Test
+                public void b() {
+                    log += "Bb";
+                }
+
+                @Test
+                public void c() {
+                    log += "Bc";
+                }
+            }
+        }
+
+        @Test
+        public void orderingForwardWorksOnSuite() {
+            Request forward = Request.aClass(Enclosing.class).orderWith(
+                    AlphanumericOrdering.INSTANCE);
+
+            new JUnitCore().run(forward);
+            assertEquals("AaAbAcBaBbBc", log);
+        }
+
+        @Test
+        public void orderingBackwardWorksOnSuite() {
+            Request backward = Request.aClass(Enclosing.class).orderWith(
+                    new ReverseAlphanumericOrdering());
+
+            new JUnitCore().run(backward);
+            assertEquals("BcBbBaAcAbAa", log);
+        }
+    }
+
+    public static class TestOrderableClassRunnerIsSortable {
+        private static String log = "";
+
+        /**
+         * A Runner that implements {@link Orderable}.
+         */
+        public static class OrderableRunner extends Runner implements Orderable {
+            private final BlockJUnit4ClassRunner delegate;
+
+            public OrderableRunner(Class<?> klass) throws Throwable {
+                delegate = new BlockJUnit4ClassRunner(klass);
+            }
+            
+            @Override
+            public void run(RunNotifier notifier) {
+                delegate.run(notifier);
+            }
+                
+            @Override
+            public Description getDescription() {
+                return delegate.getDescription();
+            }
+
+            public void order(Orderer orderer) throws InvalidOrderingException {
+                delegate.order(orderer);
+            }
+
+            public void sort(Sorter sorter) {
+                delegate.sort(sorter);
+            }
+        }
+
+        @RunWith(OrderableRunner.class)
+        public static class OrderMe {
+            @Test
+            public void a() {
+                log += "a";
+            }
+
+            @Test
+            public void b() {
+                log += "b";
+            }
+
+            @Test
+            public void c() {
+                log += "c";
+            }
+        }
+
+        @Before
+        public void resetLog() {
+            log = "";
+        }
+
+        @Test
+        public void orderingorwardWorksOnTestClassRunner() {
+            Request forward = Request.aClass(OrderMe.class).orderWith(
+                    AlphanumericOrdering.INSTANCE);
+
+            new JUnitCore().run(forward);
+            assertEquals("abc", log);
+        }
+
+        @Test
+        public void orderedBackwardWorksOnTestClassRunner() {
+            Request backward = Request.aClass(OrderMe.class).orderWith(
+                    new ReverseAlphanumericOrdering());
+
+            new JUnitCore().run(backward);
+            assertEquals("cba", log);
+        }
+    }
+
+    public static class TestClassRunnerIsOrderableWithSuiteMethod {
+        private static String log = "";
+
+        public static class OrderMe {
+            @Test
+            public void a() {
+                log += "a";
+            }
+
+            @Test
+            public void b() {
+                log += "b";
+            }
+
+            @Test
+            public void c() {
+                log += "c";
+            }
+
+            public static junit.framework.Test suite() {
+                return new JUnit4TestAdapter(OrderMe.class);
+            }
+        }
+
+        @Before
+        public void resetLog() {
+            log = "";
+        }
+
+        @Test
+        public void orderingForwardWorksOnTestClassRunner() {
+            Request forward = Request.aClass(OrderMe.class).orderWith(AlphanumericOrdering.INSTANCE);
+
+            new JUnitCore().run(forward);
+            assertEquals("abc", log);
+        }
+
+        @Test
+        public void orderingBackwardWorksOnTestClassRunner() {
+            Request backward = Request.aClass(OrderMe.class).orderWith(
+                    new ReverseAlphanumericOrdering());
+
+            new JUnitCore().run(backward);
+            assertEquals("cba", log);
+        }
+    }
+
+    public static class UnOrderableRunnersAreHandledWithoutCrashing {
+        public static class UnOrderableRunner extends Runner {
+            public UnOrderableRunner(Class<?> klass) {
+            }
+
+            @Override
+            public Description getDescription() {
+                return Description.EMPTY;
+            }
+
+            @Override
+            public void run(RunNotifier notifier) {
+            }
+        }
+
+        @RunWith(UnOrderableRunner.class)
+        public static class UnOrderable {
+            @Test
+            public void a() {
+            }
+        }
+
+        @Test
+        public void unOrderablesAreHandledWithoutCrashing() {
+            Request unordered = Request.aClass(UnOrderable.class).orderWith(
+                    AlphanumericOrdering.INSTANCE);
+            new JUnitCore().run(unordered);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/ReverseAlphanumericOrdering.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/ReverseAlphanumericOrdering.java
new file mode 100644
index 0000000..b93d5c6
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/ReverseAlphanumericOrdering.java
@@ -0,0 +1,20 @@
+package org.junit.tests.manipulation;
+
+import static java.util.Collections.reverseOrder;
+
+import org.junit.runner.manipulation.Ordering;
+
+/**
+ * An ordering that orders tests reverse alphanumerically by test name.
+ */
+public final class ReverseAlphanumericOrdering extends ComparatorBasedOrdering
+        implements Ordering.Factory {
+
+    public ReverseAlphanumericOrdering() {
+        super(reverseOrder(Comparators.alphanumeric()));
+    }
+
+    public Ordering create(Context context) {
+        return this;
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/ReverseAlphanumericSorter.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/ReverseAlphanumericSorter.java
new file mode 100644
index 0000000..415253e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/ReverseAlphanumericSorter.java
@@ -0,0 +1,16 @@
+package org.junit.tests.manipulation;
+
+import static java.util.Collections.reverseOrder;
+
+import org.junit.runner.manipulation.Ordering;
+import org.junit.runner.manipulation.Sorter;
+
+/**
+ * A sorter that orders tests reverse alphanumerically by test name.
+ */
+public final class ReverseAlphanumericSorter implements Ordering.Factory {
+
+    public Ordering create(Ordering.Context context) {
+        return new Sorter(reverseOrder(Comparators.alphanumeric()));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/SingleMethodTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/SingleMethodTest.java
new file mode 100644
index 0000000..a153407
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/SingleMethodTest.java
@@ -0,0 +1,190 @@
+package org.junit.tests.manipulation;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+
+import junit.framework.JUnit4TestAdapter;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.Filterable;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+public class SingleMethodTest {
+    public static int count;
+
+    public static class OneTimeSetup {
+        @BeforeClass
+        public static void once() {
+            count++;
+        }
+
+        @Test
+        public void one() {
+        }
+
+        @Test
+        public void two() {
+        }
+    }
+
+    @Test
+    public void oneTimeSetup() throws Exception {
+        count = 0;
+        Runner runner = Request.method(OneTimeSetup.class, "one").getRunner();
+        Result result = new JUnitCore().run(runner);
+
+        assertEquals(1, count);
+        assertEquals(1, result.getRunCount());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class ParameterizedOneTimeSetup {
+        @Parameters
+        public static List<Object[]> params() {
+            return Arrays.asList(new Object[]{1}, new Object[]{2});
+        }
+
+        public ParameterizedOneTimeSetup(int x) {
+        }
+
+        @Test
+        public void one() {
+        }
+    }
+
+    @Test
+    public void parameterizedFilterToSingleMethod() throws Exception {
+        count = 0;
+        Runner runner = Request.method(ParameterizedOneTimeSetup.class,
+                "one[0]").getRunner();
+        Result result = new JUnitCore().run(runner);
+
+        assertEquals(1, result.getRunCount());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class ParameterizedOneTimeBeforeClass {
+        @Parameters
+        public static List<Object[]> params() {
+            return Arrays.asList(new Object[]{1}, new Object[]{2});
+        }
+
+        public ParameterizedOneTimeBeforeClass(int x) {
+        }
+
+        @BeforeClass
+        public static void once() {
+            count++;
+        }
+
+        @Test
+        public void one() {
+        }
+    }
+
+
+    @Test
+    public void parameterizedBeforeClass() throws Exception {
+        count = 0;
+        JUnitCore.runClasses(ParameterizedOneTimeBeforeClass.class);
+        assertEquals(1, count);
+    }
+
+    @Test
+    public void filteringAffectsPlan() throws Exception {
+        Runner runner = Request.method(OneTimeSetup.class, "one").getRunner();
+        assertEquals(1, runner.testCount());
+    }
+
+    @Test
+    public void nonexistentMethodCreatesFailure() throws Exception {
+        assertEquals(1, new JUnitCore().run(
+                Request.method(OneTimeSetup.class, "thisMethodDontExist"))
+                .getFailureCount());
+    }
+
+    @Test(expected = NoTestsRemainException.class)
+    public void filteringAwayEverythingThrowsException() throws NoTestsRemainException {
+        Filterable runner = (Filterable) Request.aClass(OneTimeSetup.class).getRunner();
+        runner.filter(new Filter() {
+            @Override
+            public boolean shouldRun(Description description) {
+                return false;
+            }
+
+            @Override
+            public String describe() {
+                return null;
+            }
+        });
+    }
+
+    public static class TestOne {
+        @Test
+        public void a() {
+        }
+
+        @Test
+        public void b() {
+        }
+    }
+
+    public static class TestTwo {
+        @Test
+        public void a() {
+        }
+
+        @Test
+        public void b() {
+        }
+    }
+
+    @RunWith(Suite.class)
+    @SuiteClasses({TestOne.class, TestTwo.class})
+    public static class OneTwoSuite {
+    }
+
+    @Test
+    public void eliminateUnnecessaryTreeBranches() throws Exception {
+        Runner runner = Request.aClass(OneTwoSuite.class).filterWith(
+                Description.createTestDescription(TestOne.class, "a"))
+                .getRunner();
+        Description description = runner.getDescription();
+        assertEquals(1, description.getChildren().size());
+    }
+
+    public static class HasSuiteMethod {
+        @Test
+        public void a() {
+        }
+
+        @Test
+        public void b() {
+        }
+
+        public static junit.framework.Test suite() {
+            return new JUnit4TestAdapter(HasSuiteMethod.class);
+        }
+    }
+
+    @Test
+    public void classesWithSuiteMethodsAreFiltered() {
+        int testCount = Request.method(HasSuiteMethod.class, "a").getRunner().getDescription().testCount();
+        assertThat(testCount, is(1));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/SortableTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/SortableTest.java
new file mode 100644
index 0000000..5857ca0
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/manipulation/SortableTest.java
@@ -0,0 +1,302 @@
+package org.junit.tests.manipulation;
+
+import static java.util.Collections.reverseOrder;
+import static org.junit.Assert.assertEquals;
+
+import java.util.Comparator;
+
+import junit.framework.JUnit4TestAdapter;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Orderable;
+import org.junit.runner.manipulation.Sortable;
+import org.junit.runner.manipulation.Sorter;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.MethodSorters;
+
+@RunWith(Enclosed.class)
+public class SortableTest {
+    private static Comparator<Description> forward() {
+        return Comparators.alphanumeric();
+    }
+
+    private static Comparator<Description> backward() {
+        return reverseOrder(Comparators.alphanumeric());
+    }
+
+    public static class TestClassRunnerIsSortable {
+        private static String log = "";
+
+        public static class SortMe {
+            @Test
+            public void a() {
+                log += "a";
+            }
+
+            @Test
+            public void b() {
+                log += "b";
+            }
+
+            @Test
+            public void c() {
+                log += "c";
+            }
+        }
+
+        @FixMethodOrder(MethodSorters.NAME_ASCENDING)
+        public static class DoNotSortMe {
+            @Test
+            public void a() {
+                log += "a";
+            }
+
+            @Test
+            public void b() {
+                log += "b";
+            }
+
+            @Test
+            public void c() {
+                log += "c";
+            }
+        }
+
+        @Before
+        public void resetLog() {
+            log = "";
+        }
+
+        @Test
+        public void sortingForwardWorksOnTestClassRunner() {
+            Request forward = Request.aClass(SortMe.class).sortWith(forward());
+
+            new JUnitCore().run(forward);
+            assertEquals("abc", log);
+        }
+
+        @Test
+        public void sortingBackwardWorksOnTestClassRunner() {
+            Request backward = Request.aClass(SortMe.class).sortWith(backward());
+
+            new JUnitCore().run(backward);
+            assertEquals("cba", log);
+        }
+
+        @Test
+        public void sortingBackwardDoesNothingOnTestClassRunnerWithFixMethodOrder() {
+            Request backward = Request.aClass(DoNotSortMe.class).sortWith(backward());
+
+            new JUnitCore().run(backward);
+            assertEquals("abc", log);
+        }
+
+        @RunWith(Enclosed.class)
+        public static class Enclosing {
+            public static class A {
+                @Test
+                public void a() {
+                    log += "Aa";
+                }
+
+                @Test
+                public void b() {
+                    log += "Ab";
+                }
+
+                @Test
+                public void c() {
+                    log += "Ac";
+                }
+            }
+
+            public static class B {
+                @Test
+                public void a() {
+                    log += "Ba";
+                }
+
+                @Test
+                public void b() {
+                    log += "Bb";
+                }
+
+                @Test
+                public void c() {
+                    log += "Bc";
+                }
+            }
+        }
+
+        @Test
+        public void sortingForwardWorksOnSuite() {
+            Request forward = Request.aClass(Enclosing.class).sortWith(forward());
+
+            new JUnitCore().run(forward);
+            assertEquals("AaAbAcBaBbBc", log);
+        }
+
+        @Test
+        public void sortingBackwardWorksOnSuite() {
+            Request backward = Request.aClass(Enclosing.class).sortWith(backward());
+
+            new JUnitCore().run(backward);
+            assertEquals("BcBbBaAcAbAa", log);
+        }
+    }
+
+    public static class TestClassRunnerIsSortableWithSuiteMethod {
+        private static String log = "";
+
+        public static class SortMe {
+            @Test
+            public void a() {
+                log += "a";
+            }
+
+            @Test
+            public void b() {
+                log += "b";
+            }
+
+            @Test
+            public void c() {
+                log += "c";
+            }
+
+            public static junit.framework.Test suite() {
+                return new JUnit4TestAdapter(SortMe.class);
+            }
+        }
+
+        @Before
+        public void resetLog() {
+            log = "";
+        }
+
+        @Test
+        public void sortingForwardWorksOnTestClassRunner() {
+            Request forward = Request.aClass(SortMe.class).sortWith(forward());
+
+            new JUnitCore().run(forward);
+            assertEquals("abc", log);
+        }
+
+        @Test
+        public void sortingBackwardWorksOnTestClassRunner() {
+            Request backward = Request.aClass(SortMe.class).sortWith(backward());
+
+            new JUnitCore().run(backward);
+            assertEquals("cba", log);
+        }
+    }
+
+    public static class UnsortableRunnersAreHandledWithoutCrashing {
+        public static class UnsortableRunner extends Runner {
+            public UnsortableRunner(Class<?> klass) {
+            }
+
+            @Override
+            public Description getDescription() {
+                return Description.EMPTY;
+            }
+
+            @Override
+            public void run(RunNotifier notifier) {
+            }
+        }
+
+        @RunWith(UnsortableRunner.class)
+        public static class Unsortable {
+            @Test
+            public void a() {
+            }
+        }
+
+        @Test
+        public void unsortablesAreHandledWithoutCrashing() {
+            Request unsorted = Request.aClass(Unsortable.class).sortWith(forward());
+            new JUnitCore().run(unsorted);
+        }
+    }
+
+    public static class TestOnlySortableClassRunnerIsSortable {
+        private static String log = "";
+
+        /**
+         * A Runner that implements {@link Sortable} but not {@link Orderable}.
+         */
+        public static class SortableRunner extends Runner implements Sortable {
+            private final BlockJUnit4ClassRunner delegate;
+
+            public SortableRunner(Class<?> klass) throws Throwable {
+                delegate = new BlockJUnit4ClassRunner(klass);
+            }
+
+            @Override
+            public void run(RunNotifier notifier) {
+                delegate.run(notifier);
+            }
+
+            @Override
+            public Description getDescription() {
+                return delegate.getDescription();
+            }
+
+            public void sort(Sorter sorter) {
+                delegate.sort(sorter);
+            }
+        }
+
+        @RunWith(SortableRunner.class)
+        public static class SortMe {
+            @Test
+            public void a() {
+                log += "a";
+            }
+
+            @Test
+            public void b() {
+                log += "b";
+            }
+
+            @Test
+            public void c() {
+                log += "c";
+            }
+
+            public static junit.framework.Test suite() {
+                return new JUnit4TestAdapter(SortMe.class);
+            }
+        }
+
+        @Before
+        public void resetLog() {
+            log = "";
+        }
+
+        @Test
+        public void sortingForwardWorksOnTestClassRunner() {
+            Request forward = Request.aClass(SortMe.class).sortWith(forward());
+
+            new JUnitCore().run(forward);
+            assertEquals("abc", log);
+        }
+
+        @Test
+        public void sortingBackwardWorksOnTestClassRunner() {
+            Request backward = Request.aClass(SortMe.class).sortWith(backward());
+
+            new JUnitCore().run(backward);
+            assertEquals("cba", log);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/package-info.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/package-info.java
new file mode 100644
index 0000000..fc5bdf6
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/package-info.java
@@ -0,0 +1,8 @@
+/**
+ * Tests the JUnit functionality.
+ *
+ * Corresponds to {@link junit.tests.AllTests} in Junit 3.x.
+ *
+ * @since 4.0
+ */
+package org.junit.tests;
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/AllRunningTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/AllRunningTests.java
new file mode 100644
index 0000000..0c05c92
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/AllRunningTests.java
@@ -0,0 +1,17 @@
+package org.junit.tests.running;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+import org.junit.tests.running.classes.AllClassesTests;
+import org.junit.tests.running.core.AllCoreTests;
+import org.junit.tests.running.methods.AllMethodsTests;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AllClassesTests.class,
+        AllCoreTests.class,
+        AllMethodsTests.class
+})
+public class AllRunningTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/AllClassesTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/AllClassesTests.java
new file mode 100644
index 0000000..793090c
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/AllClassesTests.java
@@ -0,0 +1,24 @@
+package org.junit.tests.running.classes;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+import org.junit.tests.running.classes.parent.ParentRunnerClassLoaderTest;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        BlockJUnit4ClassRunnerTest.class,
+        ClassLevelMethodsWithIgnoredTestsTest.class,
+        EnclosedTest.class,
+        IgnoreClassTest.class,
+        ParameterizedTestTest.class,
+        ParentRunnerFilteringTest.class,
+        ParentRunnerTest.class,
+        ParentRunnerClassLoaderTest.class,
+        RunWithTest.class,
+        SuiteTest.class,
+        UseSuiteAsASuperclassTest.class,
+        ThreadsTest.class
+})
+public class AllClassesTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/BlockJUnit4ClassRunnerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/BlockJUnit4ClassRunnerTest.java
new file mode 100644
index 0000000..9a4e87a
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/BlockJUnit4ClassRunnerTest.java
@@ -0,0 +1,68 @@
+package org.junit.tests.running.classes;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.notification.RunListener;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.InitializationError;
+
+public class BlockJUnit4ClassRunnerTest {
+    public static class OuterClass {
+        public class Enclosed {
+            @Test
+            public void test() {
+            }
+        }
+    }
+
+    @Test
+    public void detectNonStaticEnclosedClass() throws Exception {
+        try {
+            new BlockJUnit4ClassRunner(OuterClass.Enclosed.class);
+        } catch (InitializationError e) {
+            List<Throwable> causes = e.getCauses();
+            assertEquals("Wrong number of causes.", 1, causes.size());
+            assertEquals(
+                    "Wrong exception.",
+                    "The inner class org.junit.tests.running.classes.BlockJUnit4ClassRunnerTest$OuterClass$Enclosed is not static.",
+                    causes.get(0).getMessage());
+        }
+    }
+
+    private static String log;
+
+    public static class MethodBlockAfterFireTestStarted {
+        public MethodBlockAfterFireTestStarted() {
+            log += " init";
+        }
+
+        @Test
+        public void test() {
+            log += " test";
+        }
+    }
+
+    @Test
+    public void methodBlockAfterFireTestStarted() {
+        log = "";
+        JUnitCore junit = new JUnitCore();
+        junit.addListener(new RunListener() {
+            @Override
+            public void testStarted(Description description) throws Exception {
+                log += " testStarted(" + description.getMethodName() + ")";
+            }
+
+            @Override
+            public void testFinished(Description description) throws Exception {
+                log += " testFinished(" + description.getMethodName() + ")";
+            }
+        });
+        junit.run(MethodBlockAfterFireTestStarted.class);
+        assertEquals(" testStarted(test) init test testFinished(test)", log);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ClassLevelMethodsWithIgnoredTestsTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ClassLevelMethodsWithIgnoredTestsTest.java
new file mode 100644
index 0000000..076988b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ClassLevelMethodsWithIgnoredTestsTest.java
@@ -0,0 +1,165 @@
+package org.junit.tests.running.classes;
+
+import static org.junit.Assert.fail;
+
+import java.util.List;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Categories.CategoryFilter;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+import org.junit.runners.model.Statement;
+
+/**
+ * Tests verifying that class-level fixtures ({@link BeforeClass} and
+ * {@link AfterClass}) and rules ({@link ClassRule}) are not executed when there
+ * are no test methods to be run in a test class because they have been ignored.
+ * 
+ */
+public class ClassLevelMethodsWithIgnoredTestsTest {
+    private static final String FAILURE_MESSAGE = "This should not have happened!";
+
+    public static class BeforeClassWithIgnoredTest {
+        @BeforeClass
+        public static void beforeClass() {
+            fail(FAILURE_MESSAGE);
+        }
+        
+        @Ignore
+        @Test
+        public void test() throws Exception {
+            fail("test() should not run");
+        }
+    }
+
+    @Test
+    public void beforeClassShouldNotRunWhenAllTestsAreIgnored() {
+        runClassAndVerifyNoFailures(BeforeClassWithIgnoredTest.class,
+                "BeforeClass should not have been executed because the test method is ignored!");
+    }
+
+    @Ignore
+    public static class BeforeClassWithIgnoredClass {
+        @BeforeClass
+        public static void beforeClass() {
+            fail(FAILURE_MESSAGE);
+        }
+
+        @Test
+        public void test() throws Exception {
+            fail("test() should not run");
+        }
+    }
+
+    @Test
+    public void beforeClassShouldNotRunWhenWholeClassIsIgnored() {
+        runClassAndVerifyNoFailures(
+                BeforeClassWithIgnoredClass.class,
+                "BeforeClass should not have been executed because the whole test class is ignored!");
+    }
+
+    public static class AfterClassWithIgnoredTest {
+        @Ignore
+        @Test
+        public void test() throws Exception {
+            fail("test() should not run");
+        }
+
+        @AfterClass
+        public static void afterClass() {
+            fail(FAILURE_MESSAGE);
+        }
+    }
+
+    @Test
+    public void afterClassShouldNotRunWhenAllTestsAreIgnored() {
+        runClassAndVerifyNoFailures(AfterClassWithIgnoredTest.class,
+                "AfterClass should not have been executed because the test method is ignored!");
+    }
+
+    public interface FilteredTests {
+    }
+
+    public static class BeforeClassWithFilteredTest {
+        @BeforeClass
+        public static void setUpClass() {
+            fail(FAILURE_MESSAGE);
+        }
+
+        @Category(FilteredTests.class)
+        @Test
+        public void test() throws Exception {
+            fail("test() should not run");
+        }
+    }
+
+    public static class HasUnfilteredTest {
+        @Test
+        public void unfilteredTest() {
+            // to prevent errors when all other tests have been filtered
+        }
+    }
+
+    @Test
+    public void beforeClassShouldNotRunWhenAllTestsAreFiltered() {
+        Result result = new JUnitCore().run(Request.classes(
+                BeforeClassWithFilteredTest.class, HasUnfilteredTest.class)
+                .filterWith(CategoryFilter.exclude(FilteredTests.class)));
+        analyseResult(
+                result,
+                "BeforeClass should not have been executed because the test method is filtered!");
+    }
+
+    public static class BrokenRule implements TestRule {
+        public Statement apply(Statement base, Description description) {
+            throw new RuntimeException("this rule is broken");
+        }
+    }
+
+    public static class ClassRuleWithIgnoredTest {
+        @ClassRule
+        public static BrokenRule brokenRule = new BrokenRule();
+
+        @Ignore
+        @Test
+        public void test() throws Exception {
+            fail("test() should not be run");
+        }
+    }
+
+    @Test
+    public void classRuleShouldNotBeAppliedWhenAllTestsAreIgnored() {
+        runClassAndVerifyNoFailures(ClassRuleWithIgnoredTest.class,
+                "The class rule should have been applied because the test method is ignored!");
+    }
+
+    private void runClassAndVerifyNoFailures(Class<?> klass,
+            String testFailureDescription) {
+        Result result = JUnitCore.runClasses(klass);
+        analyseResult(result, testFailureDescription);
+    }
+
+    private void analyseResult(Result result, String testFailureDescription) {
+        List<Failure> failures = result.getFailures();
+        if (failures.isEmpty() == false) {
+            analyzeFailure(failures.get(0), testFailureDescription);
+        }
+    }
+
+    private void analyzeFailure(Failure failure, String testFailureDescription) {
+        String actualFailureMsg = failure.getMessage();
+        if (FAILURE_MESSAGE.equals(actualFailureMsg)) {
+            fail(testFailureDescription);
+        }
+        fail("Unexpected failure : " + actualFailureMsg);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/EnclosedTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/EnclosedTest.java
new file mode 100644
index 0000000..9a8165a
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/EnclosedTest.java
@@ -0,0 +1,55 @@
+package org.junit.tests.running.classes;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+
+public class EnclosedTest {
+    @RunWith(Enclosed.class)
+    public static class Enclosing {
+        public static class A {
+            @Test
+            public void a() {}
+
+            @Test
+            public void b() {}
+        }
+        public static class B {
+            @Test
+            public void a() {}
+
+            @Test
+            public void b() {}
+
+            @Test
+            public void c() {}
+        }
+        public abstract static class C {
+            @Test public void a() {}
+        }
+    }
+
+    @Test
+    public void enclosedRunnerPlansConcreteEnclosedClasses() throws Exception {
+        Runner runner= Request.aClass(Enclosing.class).getRunner();
+        assertEquals(5, runner.testCount());
+    }
+
+    @Test
+    public void enclosedRunnerRunsConcreteEnclosedClasses() throws Exception {
+        Result result= JUnitCore.runClasses(Enclosing.class);
+        assertEquals(5, result.getRunCount());
+    }
+
+    @Test
+    public void enclosedRunnerIsNamedForEnclosingClass() throws Exception {
+        assertEquals(Enclosing.class.getName(), Request.aClass(Enclosing.class)
+                .getRunner().getDescription().getDisplayName());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/IgnoreClassTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/IgnoreClassTest.java
new file mode 100644
index 0000000..28cbe76
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/IgnoreClassTest.java
@@ -0,0 +1,31 @@
+package org.junit.tests.running.classes;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+
+public class IgnoreClassTest {
+    @Ignore("For a good reason")
+    public static class IgnoreMe {
+        @Test
+        public void iFail() {
+            fail();
+        }
+
+        @Test
+        public void iFailToo() {
+            fail();
+        }
+    }
+
+    @Test
+    public void ignoreClass() {
+        Result result = JUnitCore.runClasses(IgnoreMe.class);
+        assertEquals(0, result.getFailureCount());
+        assertEquals(1, result.getIgnoreCount());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ParameterizedTestTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ParameterizedTestTest.java
new file mode 100644
index 0000000..6288dbc
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ParameterizedTestTest.java
@@ -0,0 +1,809 @@
+package org.junit.tests.running.classes;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
+import static org.junit.experimental.results.PrintableResult.testResult;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runner.notification.Failure;
+import org.junit.runners.MethodSorters;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.junit.runners.Parameterized.UseParametersRunnerFactory;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.parameterized.ParametersRunnerFactory;
+import org.junit.runners.parameterized.TestWithParameters;
+
+public class ParameterizedTestTest {
+    @RunWith(Parameterized.class)
+    public static class AdditionTest {
+        @Parameters(name = "{index}: {0} + {1} = {2}")
+        public static Iterable<Object[]> data() {
+            return Arrays.asList(new Object[][] { { 0, 0, 0 }, { 1, 1, 2 },
+                    { 3, 2, 5 }, { 4, 3, 7 } });
+        }
+
+        private int firstSummand;
+
+        private int secondSummand;
+
+        private int sum;
+
+        public AdditionTest(int firstSummand, int secondSummand, int sum) {
+            this.firstSummand = firstSummand;
+            this.secondSummand = secondSummand;
+            this.sum = sum;
+        }
+
+        @Test
+        public void test() {
+            assertEquals(sum, firstSummand + secondSummand);
+        }
+    }
+
+    @Test
+    public void countsRuns() {
+        Result result = JUnitCore.runClasses(AdditionTest.class);
+        assertEquals(4, result.getRunCount());
+    }
+
+    @Test
+    public void countBeforeRun() throws Exception {
+        Runner runner = Request.aClass(AdditionTest.class).getRunner();
+        assertEquals(4, runner.testCount());
+    }
+
+    @Test
+    public void plansNamedCorrectly() throws Exception {
+        Runner runner = Request.aClass(AdditionTest.class).getRunner();
+        Description description = runner.getDescription();
+        assertEquals("[2: 3 + 2 = 5]", description.getChildren().get(2)
+                .getDisplayName());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class ThreeFailures {
+        @Parameters(name = "{index}: x={0}")
+        public static Collection<Integer> data() {
+            return Arrays.asList(1, 2, 3);
+        }
+
+        @Parameter(0)
+        public int unused;
+
+        @Test
+        public void testSomething() {
+            fail();
+        }
+    }
+
+    @Test
+    public void countsFailures() throws Exception {
+        Result result = JUnitCore.runClasses(ThreeFailures.class);
+        assertEquals(3, result.getFailureCount());
+    }
+
+    @Test
+    public void failuresNamedCorrectly() {
+        Result result = JUnitCore.runClasses(ThreeFailures.class);
+        assertEquals(
+                "testSomething[0: x=1](" + ThreeFailures.class.getName() + ")",
+                result.getFailures().get(0).getTestHeader());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class ParameterizedWithoutSpecialTestname {
+        @Parameters
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{{3}, {3}});
+        }
+
+        public ParameterizedWithoutSpecialTestname(Object something) {
+        }
+
+        @Test
+        public void testSomething() {
+        }
+    }
+
+    @Test
+    public void usesIndexAsTestName() {
+        Runner runner = Request
+                .aClass(ParameterizedWithoutSpecialTestname.class).getRunner();
+        Description description = runner.getDescription();
+        assertEquals("[1]", description.getChildren().get(1).getDisplayName());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class AdditionTestWithAnnotatedFields {
+        @Parameters(name = "{index}: {0} + {1} = {2}")
+        public static Iterable<Object[]> data() {
+            return Arrays.asList(new Object[][] { { 0, 0, 0 }, { 1, 1, 2 },
+                    { 3, 2, 5 }, { 4, 3, 7 } });
+        }
+
+        @Parameter(0)
+        public int firstSummand;
+
+        @Parameter(1)
+        public int secondSummand;
+
+        @Parameter(2)
+        public int sum;
+
+        @Test
+        public void test() {
+            assertEquals(sum, firstSummand + secondSummand);
+        }
+    }
+
+    @Test
+    public void providesDataByAnnotatedFields() {
+        Result result = JUnitCore.runClasses(AdditionTestWithAnnotatedFields.class);
+        assertEquals(4, result.getRunCount());
+        assertEquals(0, result.getFailureCount());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class BadIndexForAnnotatedFieldTest {
+        @Parameters
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{{0}});
+        }
+
+        @Parameter(2)
+        public int fInput;
+
+        public int fExpected;
+
+        @Test
+        public void test() {
+            assertEquals(fExpected, fib(fInput));
+        }
+
+        private int fib(int x) {
+            return 0;
+        }
+    }
+
+    @Test
+    public void failureOnInitialization() {
+        Result result = JUnitCore.runClasses(BadIndexForAnnotatedFieldTest.class);
+        assertEquals(1, result.getFailureCount());
+        List<Failure> failures = result.getFailures();
+        assertThat(failures.get(0).getException().getMessage(), allOf(
+                containsString("Invalid @Parameter value: 2. @Parameter fields counted: 1. Please use an index between 0 and 0."),
+                containsString("@Parameter(0) is never used.")));
+    }
+
+    @RunWith(Parameterized.class)
+    public static class BadNumberOfAnnotatedFieldTest {
+        @Parameters
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{{0, 0}});
+        }
+
+        @Parameter(0)
+        public int fInput;
+
+        public int fExpected;
+
+        @Test
+        public void test() {
+            assertEquals(fExpected, fib(fInput));
+        }
+
+        private int fib(int x) {
+            return 0;
+        }
+    }
+
+    @Test
+    public void numberOfFieldsAndParametersShouldMatch() {
+        Result result = JUnitCore.runClasses(BadNumberOfAnnotatedFieldTest.class);
+        assertEquals(1, result.getFailureCount());
+        List<Failure> failures = result.getFailures();
+        assertTrue(failures.get(0).getException().getMessage().contains("Wrong number of parameters and @Parameter fields. @Parameter fields counted: 1, available parameters: 2."));
+    }
+
+    private static String fLog;
+
+    @RunWith(Parameterized.class)
+    public static class BeforeAndAfter {
+        @BeforeClass
+        public static void before() {
+            fLog += "before ";
+        }
+
+        @AfterClass
+        public static void after() {
+            fLog += "after ";
+        }
+
+        public BeforeAndAfter(int x) {
+
+        }
+
+        @Parameters
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{{3}});
+        }
+
+        @Test
+        public void aTest() {
+        }
+    }
+
+    @Test
+    public void beforeAndAfterClassAreRun() {
+        fLog = "";
+        JUnitCore.runClasses(BeforeAndAfter.class);
+        assertEquals("before after ", fLog);
+    }
+
+    @RunWith(Parameterized.class)
+    @FixMethodOrder(MethodSorters.NAME_ASCENDING)
+    public static class BeforeParamAndAfterParam {
+        @BeforeClass
+        public static void before() {
+            fLog += "beforeClass ";
+        }
+
+        @Parameterized.BeforeParam
+        public static void beforeParam(String x) {
+            fLog += "before(" + x + ") ";
+        }
+
+        @Parameterized.AfterParam
+        public static void afterParam() {
+            fLog += "afterParam ";
+        }
+
+        @AfterClass
+        public static void after() {
+            fLog += "afterClass ";
+        }
+
+        private final String x;
+
+        public BeforeParamAndAfterParam(String x) {
+            this.x = x;
+        }
+
+        @Parameters
+        public static Collection<String> data() {
+            return Arrays.asList("A", "B");
+        }
+
+        @Test
+        public void first() {
+            fLog += "first(" + x + ") ";
+        }
+
+        @Test
+        public void second() {
+            fLog += "second(" + x + ") ";
+        }
+    }
+
+    @Test
+    public void beforeParamAndAfterParamAreRun() {
+        fLog = "";
+        Result result = JUnitCore.runClasses(BeforeParamAndAfterParam.class);
+        assertEquals(0, result.getFailureCount());
+        assertEquals("beforeClass before(A) first(A) second(A) afterParam "
+                + "before(B) first(B) second(B) afterParam afterClass ", fLog);
+    }
+
+    @RunWith(Parameterized.class)
+    @FixMethodOrder(MethodSorters.NAME_ASCENDING)
+    public static class MultipleBeforeParamAndAfterParam {
+        @Parameterized.BeforeParam
+        public static void before1() {
+            fLog += "before1() ";
+        }
+
+        @Parameterized.BeforeParam
+        public static void before2(String x) {
+            fLog += "before2(" + x + ") ";
+        }
+
+        @Parameterized.AfterParam
+        public static void after2() {
+            fLog += "after2() ";
+        }
+
+        @Parameterized.AfterParam
+        public static void after1(String x) {
+            fLog += "after1(" + x + ") ";
+        }
+
+        private final String x;
+
+        public MultipleBeforeParamAndAfterParam(String x) {
+            this.x = x;
+        }
+
+        @Parameters
+        public static Collection<String> data() {
+            return Arrays.asList("A", "B");
+        }
+
+        @Test
+        public void first() {
+            fLog += "first(" + x + ") ";
+        }
+
+        @Test
+        public void second() {
+            fLog += "second(" + x + ") ";
+        }
+    }
+
+    @Test
+    public void multipleBeforeParamAndAfterParamAreRun() {
+        fLog = "";
+        Result result = JUnitCore.runClasses(MultipleBeforeParamAndAfterParam.class);
+        assertEquals(0, result.getFailureCount());
+        assertEquals("before1() before2(A) first(A) second(A) after1(A) after2() "
+                + "before1() before2(B) first(B) second(B) after1(B) after2() ", fLog);
+    }
+
+    @RunWith(Parameterized.class)
+    @FixMethodOrder(MethodSorters.NAME_ASCENDING)
+    public static class MultipleParametersBeforeParamAndAfterParam {
+        @Parameterized.BeforeParam
+        public static void before(String x, int y) {
+            fLog += "before(" + x + "," + y + ") ";
+        }
+
+        @Parameterized.AfterParam
+        public static void after(String x, int y) {
+            fLog += "after(" + x + "," + y + ") ";
+        }
+
+        private final String x;
+        private final int y;
+
+        public MultipleParametersBeforeParamAndAfterParam(String x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Parameters
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[]{"A", 1}, new Object[]{"B", 2});
+        }
+
+        @Test
+        public void first() {
+            fLog += "first(" + x + "," + y + ") ";
+        }
+
+        @Test
+        public void second() {
+            fLog += "second(" + x + "," + y + ") ";
+        }
+    }
+
+    @Test
+    public void multipleParametersBeforeParamAndAfterParamAreRun() {
+        fLog = "";
+        Result result = JUnitCore.runClasses(MultipleParametersBeforeParamAndAfterParam.class);
+        assertEquals(0, result.getFailureCount());
+        assertEquals("before(A,1) first(A,1) second(A,1) after(A,1) "
+                + "before(B,2) first(B,2) second(B,2) after(B,2) ", fLog);
+    }
+
+    @RunWith(Parameterized.class)
+    public static class BeforeParamAndAfterParamError {
+        @Parameterized.BeforeParam
+        public void beforeParam(String x) {
+        }
+
+        @Parameterized.AfterParam
+        private static void afterParam() {
+        }
+
+        public BeforeParamAndAfterParamError(String x) {
+        }
+
+        @Parameters
+        public static Collection<String> data() {
+            return Arrays.asList("A", "B");
+        }
+
+        @Test
+        public void test() {
+        }
+    }
+
+    @Test
+    public void beforeParamAndAfterParamValidation() {
+        fLog = "";
+        Result result = JUnitCore.runClasses(BeforeParamAndAfterParamError.class);
+        assertEquals(1, result.getFailureCount());
+        List<Failure> failures = result.getFailures();
+        assertThat(failures.get(0).getMessage(), containsString("beforeParam() should be static"));
+        assertThat(failures.get(0).getMessage(), containsString("afterParam() should be public"));
+    }
+
+    @RunWith(Parameterized.class)
+    public static class BeforeParamAndAfterParamErrorNumberOfParameters {
+        @Parameterized.BeforeParam
+        public static void beforeParam(String x, String y) {
+        }
+
+        @Parameterized.AfterParam
+        public static void afterParam(String x, String y, String z) {
+        }
+
+        public BeforeParamAndAfterParamErrorNumberOfParameters(String x) {
+        }
+
+        @Parameters
+        public static Collection<String> data() {
+            return Arrays.asList("A", "B", "C", "D");
+        }
+
+        @Test
+        public void test() {
+        }
+    }
+
+    @Test
+    public void beforeParamAndAfterParamValidationNumberOfParameters() {
+        fLog = "";
+        Result result = JUnitCore.runClasses(BeforeParamAndAfterParamErrorNumberOfParameters.class);
+        assertEquals(1, result.getFailureCount());
+        List<Failure> failures = result.getFailures();
+        assertThat(failures.get(0).getMessage(),
+                containsString("Method beforeParam() should have 0 or 1 parameter(s)"));
+        assertThat(failures.get(0).getMessage(),
+                containsString("Method afterParam() should have 0 or 1 parameter(s)"));
+    }
+
+    @RunWith(Parameterized.class)
+    public static class EmptyTest {
+        @BeforeClass
+        public static void before() {
+            fLog += "before ";
+        }
+
+        @AfterClass
+        public static void after() {
+            fLog += "after ";
+        }
+    }
+
+    @Test
+    public void validateClassCatchesNoParameters() {
+        Result result = JUnitCore.runClasses(EmptyTest.class);
+        assertEquals(1, result.getFailureCount());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class IncorrectTest {
+        @Test
+        public int test() {
+            return 0;
+        }
+
+        @Parameters
+        public static Collection<Object[]> data() {
+            return Collections.singletonList(new Object[]{1});
+        }
+    }
+
+    @Test
+    public void failuresAddedForBadTestMethod() throws Exception {
+        Result result = JUnitCore.runClasses(IncorrectTest.class);
+        assertEquals(1, result.getFailureCount());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class ProtectedParametersTest {
+        @Parameters
+        protected static Collection<Object[]> data() {
+            return Collections.emptyList();
+        }
+
+        @Test
+        public void aTest() {
+        }
+    }
+
+    @Test
+    public void meaningfulFailureWhenParametersNotPublic() {
+        assertTestCreatesSingleFailureWithMessage(ProtectedParametersTest.class,
+                "No public static parameters method on class "
+                        + ProtectedParametersTest.class.getName());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class ParametersNotIterable {
+        @Parameters
+        public static String data() {
+            return "foo";
+        }
+
+        @Test
+        public void aTest() {
+        }
+    }
+
+    @Test
+    public void meaningfulFailureWhenParametersAreNotAnIterable() {
+        assertThat(
+                testResult(ParametersNotIterable.class).toString(),
+                containsString("ParametersNotIterable.data() must return an Iterable of arrays."));
+    }
+
+    @RunWith(Parameterized.class)
+    public static class PrivateConstructor {
+        private PrivateConstructor(int x) {
+
+        }
+
+        @Parameters
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{{3}});
+        }
+
+        @Test
+        public void aTest() {
+        }
+    }
+
+    @Test(expected = InitializationError.class)
+    public void exceptionWhenPrivateConstructor() throws Throwable {
+        new Parameterized(PrivateConstructor.class);
+    }
+
+    @RunWith(Parameterized.class)
+    public static class AdditionTestWithArray {
+        @Parameters(name = "{index}: {0} + {1} = {2}")
+        public static Object[][] data() {
+            return new Object[][] { { 0, 0, 0 }, { 1, 1, 2 }, { 3, 2, 5 },
+                    { 4, 3, 7 } };
+        }
+
+        @Parameter(0)
+        public int firstSummand;
+
+        @Parameter(1)
+        public int secondSummand;
+
+        @Parameter(2)
+        public int sum;
+
+        @Test
+        public void test() {
+            assertEquals(sum, firstSummand + secondSummand);
+        }
+    }
+
+    @Test
+    public void runsEveryTestOfArray() {
+        Result result= JUnitCore.runClasses(AdditionTestWithArray.class);
+        assertEquals(4, result.getRunCount());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class SingleArgumentTestWithArray {
+        @Parameters
+        public static Object[] data() {
+            return new Object[] { "first test", "second test" };
+        }
+
+        public SingleArgumentTestWithArray(Object argument) {
+        }
+
+        @Test
+        public void aTest() {
+        }
+    }
+
+    @Test
+    public void runsForEverySingleArgumentOfArray() {
+        Result result= JUnitCore.runClasses(SingleArgumentTestWithArray.class);
+        assertEquals(2, result.getRunCount());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class SingleArgumentTestWithIterable {
+        private static final AtomicBoolean dataCalled = new AtomicBoolean(false);
+
+        @Parameters
+        public static Iterable<? extends Object> data() {
+            if (!dataCalled.compareAndSet(false, true)) {
+                fail("Should not call @Parameters method more than once");
+            }
+            return new OneShotIterable<String>(asList("first test", "second test"));
+        }
+
+        public SingleArgumentTestWithIterable(Object argument) {
+        }
+
+        @Test
+        public void aTest() {
+        }
+  	}
+
+    private static class OneShotIterable<T> implements Iterable<T> {
+        private final Iterable<T> delegate;
+        private final AtomicBoolean iterated = new AtomicBoolean(false);
+
+        OneShotIterable(Iterable<T> delegate) {
+            this.delegate = delegate;
+        }
+
+        public Iterator<T> iterator() {
+            if (iterated.compareAndSet(false, true)) {
+                return delegate.iterator();
+            }
+            throw new IllegalStateException("Cannot call iterator() more than once");
+        }
+    }
+
+    @Test
+    public void runsForEverySingleArgumentOfIterable() {
+        Result result= JUnitCore
+                .runClasses(SingleArgumentTestWithIterable.class);
+        assertEquals(2, result.getRunCount());
+    }
+
+    @RunWith(Parameterized.class)
+    public static class SingleArgumentTestWithCollection {
+        @Parameters
+        public static Iterable<? extends Object> data() {
+            return Collections.unmodifiableCollection(asList("first test", "second test"));
+        }
+
+        public SingleArgumentTestWithCollection(Object argument) {
+        }
+
+        @Test
+        public void aTest() {
+        }
+    }
+
+    @Test
+    public void runsForEverySingleArgumentOfCollection() {
+        Result result= JUnitCore
+                .runClasses(SingleArgumentTestWithCollection.class);
+        assertEquals(2, result.getRunCount());
+    }
+
+
+    public static class ExceptionThrowingRunnerFactory implements
+            ParametersRunnerFactory {
+        public Runner createRunnerForTestWithParameters(TestWithParameters test)
+                throws InitializationError {
+            throw new InitializationError(
+                    "Called ExceptionThrowingRunnerFactory.");
+        }
+    }
+
+    @RunWith(Parameterized.class)
+    @UseParametersRunnerFactory(ExceptionThrowingRunnerFactory.class)
+    public static class TestWithUseParametersRunnerFactoryAnnotation {
+        @Parameters
+        public static Iterable<? extends Object> data() {
+            return asList("single test");
+        }
+
+        public TestWithUseParametersRunnerFactoryAnnotation(Object argument) {
+        }
+
+        @Test
+        public void aTest() {
+        }
+    }
+
+    @Test
+    public void usesParametersRunnerFactoryThatWasSpecifiedByAnnotation() {
+        assertTestCreatesSingleFailureWithMessage(
+                TestWithUseParametersRunnerFactoryAnnotation.class,
+                "Called ExceptionThrowingRunnerFactory.");
+    }
+
+    private void assertTestCreatesSingleFailureWithMessage(Class<?> test, String message) {
+        Result result = JUnitCore.runClasses(test);
+        assertEquals(1, result.getFailures().size());
+        assertEquals(message, result.getFailures().get(0).getMessage());
+    }
+    
+    @RunWith(Parameterized.class)
+    @UseParametersRunnerFactory(ExceptionThrowingRunnerFactory.class)
+    public abstract static class UseParameterizedFactoryAbstractTest {
+        @Parameters
+        public static Iterable<? extends Object> data() {
+            return asList("single test");
+        }
+    }
+    
+    public static class UseParameterizedFactoryTest extends
+            UseParameterizedFactoryAbstractTest {
+
+        public UseParameterizedFactoryTest(String parameter) {
+
+        }
+
+        @Test
+        public void parameterizedTest() {
+        }
+    }
+    
+    @Test
+    public void usesParametersRunnerFactoryThatWasSpecifiedByAnnotationInSuperClass() {
+        assertTestCreatesSingleFailureWithMessage(
+                UseParameterizedFactoryTest.class,
+                "Called ExceptionThrowingRunnerFactory.");
+    }
+
+    @RunWith(Parameterized.class)
+    public static class AssumptionInParametersMethod {
+        static boolean assumptionFails;
+
+        @Parameters
+        public static Iterable<String> data() {
+            assumeFalse(assumptionFails);
+            return Collections.singletonList("foobar");
+        }
+
+        public AssumptionInParametersMethod(String parameter) {
+        }
+
+        @Test
+        public void test1() {
+        }
+
+        @Test
+        public void test2() {
+        }
+    }
+
+    @Test
+    public void testsAreExecutedWhenAssumptionInParametersMethodDoesNotFail() {
+        AssumptionInParametersMethod.assumptionFails = false;
+        Result result = JUnitCore.runClasses(AssumptionInParametersMethod.class);
+        assertTrue(result.wasSuccessful());
+        assertEquals(0, result.getAssumptionFailureCount());
+        assertEquals(0, result.getIgnoreCount());
+        assertEquals(2, result.getRunCount());
+    }
+
+    @Test
+    public void testsAreNotExecutedWhenAssumptionInParametersMethodFails() {
+        AssumptionInParametersMethod.assumptionFails = true;
+        Result result = JUnitCore.runClasses(AssumptionInParametersMethod.class);
+        assertTrue(result.wasSuccessful());
+        assertEquals(1, result.getAssumptionFailureCount());
+        assertEquals(0, result.getIgnoreCount());
+        assertEquals(0, result.getRunCount());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ParentRunnerFilteringTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ParentRunnerFilteringTest.java
new file mode 100644
index 0000000..1c1d9d1
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ParentRunnerFilteringTest.java
@@ -0,0 +1,171 @@
+package org.junit.tests.running.classes;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining;
+import static org.junit.runner.Description.createSuiteDescription;
+import static org.junit.runner.Description.createTestDescription;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.RunnerBuilder;
+
+public class ParentRunnerFilteringTest {
+    private static Filter notThisMethodName(final String methodName) {
+        return new Filter() {
+            @Override
+            public boolean shouldRun(Description description) {
+                return description.getMethodName() == null
+                        || !description.getMethodName().equals(methodName);
+            }
+
+            @Override
+            public String describe() {
+                return "don't run method name: " + methodName;
+            }
+        };
+    }
+
+    private static class CountingFilter extends Filter {
+        private final Map<Description, Integer> countMap = new HashMap<Description, Integer>();
+
+        @Override
+        public boolean shouldRun(Description description) {
+            Integer count = countMap.get(description);
+            if (count == null) {
+                countMap.put(description, 1);
+            } else {
+                countMap.put(description, count + 1);
+            }
+            return true;
+        }
+
+        @Override
+        public String describe() {
+            return "filter counter";
+        }
+
+        public int getCount(final Description desc) {
+            if (!countMap.containsKey(desc)) {
+                throw new IllegalArgumentException("Looking for " + desc
+                        + ", but only contains: " + countMap.keySet());
+            }
+            return countMap.get(desc);
+        }
+    }
+
+    public static class ExampleTest {
+        @Test
+        public void test1() throws Exception {
+            // passes
+        }
+    }
+
+    @RunWith(Suite.class)
+    @SuiteClasses({ExampleTest.class})
+    public static class ExampleSuite {
+    }
+
+    @Test
+    public void testSuiteFiltering() throws Exception {
+        Runner runner = Request.aClass(ExampleSuite.class).getRunner();
+        Filter filter = notThisMethodName("test1");
+        try {
+            filter.apply(runner);
+        } catch (NoTestsRemainException e) {
+            return;
+        }
+        fail("Expected 'NoTestsRemainException' due to complete filtering");
+    }
+
+    public static class SuiteWithUnmodifiableChildList extends Suite {
+
+        public SuiteWithUnmodifiableChildList(
+                Class<?> klass, RunnerBuilder builder)
+                throws InitializationError {
+            super(klass, builder);
+        }
+
+        @Override
+        protected List<Runner> getChildren() {
+            return Collections.unmodifiableList(super.getChildren());
+        }
+    }
+
+    @RunWith(SuiteWithUnmodifiableChildList.class)
+    @SuiteClasses({ExampleTest.class})
+    public static class ExampleSuiteWithUnmodifiableChildList {
+    }
+
+    @Test
+    public void testSuiteFilteringWithUnmodifiableChildList() throws Exception {
+        Runner runner = Request.aClass(ExampleSuiteWithUnmodifiableChildList.class)
+                .getRunner();
+        Filter filter = notThisMethodName("test1");
+        try {
+            filter.apply(runner);
+        } catch (NoTestsRemainException e) {
+            return;
+        }
+        fail("Expected 'NoTestsRemainException' due to complete filtering");
+    }
+
+    @Test
+    public void testRunSuiteFiltering() throws Exception {
+        Request request = Request.aClass(ExampleSuite.class);
+        Request requestFiltered = request.filterWith(notThisMethodName("test1"));
+        assertThat(testResult(requestFiltered),
+                hasSingleFailureContaining("don't run method name: test1"));
+    }
+
+    @Test
+    public void testCountClassFiltering() throws Exception {
+        JUnitCore junitCore = new JUnitCore();
+        Request request = Request.aClass(ExampleTest.class);
+        CountingFilter countingFilter = new CountingFilter();
+        Request requestFiltered = request.filterWith(countingFilter);
+        Result result = junitCore.run(requestFiltered);
+        assertEquals(1, result.getRunCount());
+        assertEquals(0, result.getFailureCount());
+
+        Description desc = createTestDescription(ExampleTest.class, "test1");
+        assertEquals(1, countingFilter.getCount(desc));
+    }
+
+    @Test
+    public void testCountSuiteFiltering() throws Exception {
+        Class<ExampleSuite> suiteClazz = ExampleSuite.class;
+        Class<ExampleTest> clazz = ExampleTest.class;
+
+        JUnitCore junitCore = new JUnitCore();
+        Request request = Request.aClass(suiteClazz);
+        CountingFilter countingFilter = new CountingFilter();
+        Request requestFiltered = request.filterWith(countingFilter);
+        Result result = junitCore.run(requestFiltered);
+        assertEquals(1, result.getRunCount());
+        assertEquals(0, result.getFailureCount());
+
+        Description suiteDesc = createSuiteDescription(clazz);
+        assertEquals(1, countingFilter.getCount(suiteDesc));
+
+        Description desc = createTestDescription(ExampleTest.class, "test1");
+        assertEquals(1, countingFilter.getCount(desc));
+    }
+}
\ No newline at end of file
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ParentRunnerTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ParentRunnerTest.java
new file mode 100644
index 0000000..9b18ed1
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ParentRunnerTest.java
@@ -0,0 +1,310 @@
+package org.junit.tests.running.classes;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.ParentRunner;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.RunnerScheduler;
+import org.junit.rules.RuleMemberValidatorTest.TestWithNonStaticClassRule;
+import org.junit.rules.RuleMemberValidatorTest.TestWithProtectedClassRule;
+
+public class ParentRunnerTest {
+    public static String log = "";
+
+    public static class FruitTest {
+        @Test
+        public void apple() {
+            log += "apple ";
+        }
+
+        @Test
+        public void /* must hash-sort after "apple" */Banana() {
+            log += "banana ";
+        }
+    }
+
+    @Test
+    public void useChildHarvester() throws InitializationError {
+        log = "";
+        ParentRunner<?> runner = new BlockJUnit4ClassRunner(FruitTest.class);
+        runner.setScheduler(new RunnerScheduler() {
+            public void schedule(Runnable childStatement) {
+                log += "before ";
+                childStatement.run();
+                log += "after ";
+            }
+
+            public void finished() {
+                log += "afterAll ";
+            }
+        });
+
+        runner.run(new RunNotifier());
+        assertEquals("before apple after before banana after afterAll ", log);
+    }
+
+    @Test
+    public void testMultipleFilters() throws Exception {
+        JUnitCore junitCore = new JUnitCore();
+        Request request = Request.aClass(ExampleTest.class);
+        Request requestFiltered = request.filterWith(new Exclude("test1"));
+        Request requestFilteredFiltered = requestFiltered
+                .filterWith(new Exclude("test2"));
+        Result result = junitCore.run(requestFilteredFiltered);
+        assertThat(result.getFailures(), isEmpty());
+        assertEquals(1, result.getRunCount());
+    }
+
+    private Matcher<List<?>> isEmpty() {
+        return new TypeSafeMatcher<List<?>>() {
+            public void describeTo(org.hamcrest.Description description) {
+                description.appendText("is empty");
+            }
+
+            @Override
+            public boolean matchesSafely(List<?> item) {
+                return item.size() == 0;
+            }
+        };
+    }
+
+    private static class Exclude extends Filter {
+        private final String methodName;
+
+        public Exclude(String methodName) {
+            this.methodName = methodName;
+        }
+
+        @Override
+        public boolean shouldRun(Description description) {
+            return !description.getMethodName().equals(methodName);
+        }
+
+        @Override
+        public String describe() {
+            return "filter method name: " + methodName;
+        }
+    }
+
+    public static class ExampleTest {
+        @Test
+        public void test1() throws Exception {
+        }
+
+        @Test
+        public void test2() throws Exception {
+        }
+
+        @Test
+        public void test3() throws Exception {
+        }
+    }
+
+    @Test
+    public void failWithHelpfulMessageForProtectedClassRule() {
+        assertClassHasFailureMessage(TestWithProtectedClassRule.class,
+                "The @ClassRule 'temporaryFolder' must be public.");
+    }
+
+    @Test
+    public void failWithHelpfulMessageForNonStaticClassRule() {
+        assertClassHasFailureMessage(TestWithNonStaticClassRule.class,
+                "The @ClassRule 'temporaryFolder' must be static.");
+    }
+
+    static class NonPublicTestClass {
+        public NonPublicTestClass() {
+        }
+
+        @Test
+        public void alwaysPasses() {}
+    }
+
+    @Test
+    public void cannotBeCreatedWithNonPublicTestClass() {
+        assertClassHasFailureMessage(
+                NonPublicTestClass.class,
+                "The class org.junit.tests.running.classes.ParentRunnerTest$NonPublicTestClass is not public.");
+    }
+
+    private void assertClassHasFailureMessage(Class<?> klass, String message) {
+        JUnitCore junitCore = new JUnitCore();
+        Request request = Request.aClass(klass);
+        Result result = junitCore.run(request);
+        assertThat(result.getFailureCount(), is(1));
+        assertThat(result.getFailures().get(0).getMessage(),
+                containsString(message));
+    }
+
+    public static class AssertionErrorAtParentLevelTest {
+        @BeforeClass
+        public static void beforeClass() throws Throwable {
+            throw new AssertionError("Thrown from @BeforeClass");
+        }
+
+        @Test
+        public void test() {}
+    }
+
+    @Test
+    public void assertionErrorAtParentLevelTest() throws InitializationError {
+        CountingRunListener countingRunListener = runTestWithParentRunner(AssertionErrorAtParentLevelTest.class);
+        Assert.assertEquals(1, countingRunListener.testSuiteStarted);
+        Assert.assertEquals(1, countingRunListener.testSuiteFinished);
+        Assert.assertEquals(1, countingRunListener.testSuiteFailure);
+        Assert.assertEquals(0, countingRunListener.testSuiteAssumptionFailure);
+
+        Assert.assertEquals(0, countingRunListener.testStarted);
+        Assert.assertEquals(0, countingRunListener.testFinished);
+        Assert.assertEquals(0, countingRunListener.testFailure);
+        Assert.assertEquals(0, countingRunListener.testAssumptionFailure);
+        Assert.assertEquals(0, countingRunListener.testIgnored);
+    }
+
+    public static class AssumptionViolatedAtParentLevelTest {
+        @SuppressWarnings("deprecation")
+        @BeforeClass
+        public static void beforeClass() {
+            throw new AssumptionViolatedException("Thrown from @BeforeClass");
+        }
+
+        @Test
+        public void test() {}
+    }
+
+    @Test
+    public void assumptionViolatedAtParentLevel() throws InitializationError {
+        CountingRunListener countingRunListener = runTestWithParentRunner(AssumptionViolatedAtParentLevelTest.class);
+        Assert.assertEquals(1, countingRunListener.testSuiteStarted);
+        Assert.assertEquals(1, countingRunListener.testSuiteFinished);
+        Assert.assertEquals(0, countingRunListener.testSuiteFailure);
+        Assert.assertEquals(1, countingRunListener.testSuiteAssumptionFailure);
+
+        Assert.assertEquals(0, countingRunListener.testStarted);
+        Assert.assertEquals(0, countingRunListener.testFinished);
+        Assert.assertEquals(0, countingRunListener.testFailure);
+        Assert.assertEquals(0, countingRunListener.testAssumptionFailure);
+        Assert.assertEquals(0, countingRunListener.testIgnored);
+    }
+
+    public static class TestTest {
+        @Test
+        public void pass() {}
+
+        @Test
+        public void fail() {
+            throw new AssertionError("Thrown from @Test");
+        }
+
+        @Ignore
+        @Test
+        public void ignore() {}
+
+        @SuppressWarnings("deprecation")
+        @Test
+        public void assumptionFail() {
+            throw new AssumptionViolatedException("Thrown from @Test");
+        }
+    }
+
+    @Test
+    public void parentRunnerTestMethods() throws InitializationError {
+        CountingRunListener countingRunListener = runTestWithParentRunner(TestTest.class);
+        Assert.assertEquals(1, countingRunListener.testSuiteStarted);
+        Assert.assertEquals(1, countingRunListener.testSuiteFinished);
+        Assert.assertEquals(0, countingRunListener.testSuiteFailure);
+        Assert.assertEquals(0, countingRunListener.testSuiteAssumptionFailure);
+
+        Assert.assertEquals(3, countingRunListener.testStarted);
+        Assert.assertEquals(3, countingRunListener.testFinished);
+        Assert.assertEquals(1, countingRunListener.testFailure);
+        Assert.assertEquals(1, countingRunListener.testAssumptionFailure);
+        Assert.assertEquals(1, countingRunListener.testIgnored);
+    }
+
+    private CountingRunListener runTestWithParentRunner(Class<?> testClass) throws InitializationError {
+        CountingRunListener listener = new CountingRunListener();
+        RunNotifier runNotifier = new RunNotifier();
+        runNotifier.addListener(listener);
+        ParentRunner<?> runner = new BlockJUnit4ClassRunner(testClass);
+        runner.run(runNotifier);
+        return listener;
+    }
+
+    private static class CountingRunListener extends RunListener {
+        private int testSuiteStarted = 0;
+        private int testSuiteFinished = 0;
+        private int testSuiteFailure = 0;
+        private int testSuiteAssumptionFailure = 0;
+
+        private int testStarted = 0;
+        private int testFinished = 0;
+        private int testFailure = 0;
+        private int testAssumptionFailure = 0;
+        private int testIgnored = 0;
+
+        @Override
+        public void testSuiteStarted(Description description) throws Exception {
+            testSuiteStarted++;
+        }
+
+        @Override
+        public void testSuiteFinished(Description description) throws Exception {
+            testSuiteFinished++;
+        }
+
+        @Override
+        public void testStarted(Description description) throws Exception {
+            testStarted++;
+        }
+
+        @Override
+        public void testFinished(Description description) throws Exception {
+            testFinished++;
+        }
+
+        @Override
+        public void testFailure(Failure failure) throws Exception {
+            if (failure.getDescription().isSuite()) {
+                testSuiteFailure++;
+            } else {
+                testFailure++;
+            }
+        }
+
+        @Override
+        public void testAssumptionFailure(Failure failure) {
+            if (failure.getDescription().isSuite()) {
+                testSuiteAssumptionFailure++;
+            } else {
+                testAssumptionFailure++;
+            }
+        }
+
+        @Override
+        public void testIgnored(Description description) throws Exception {
+            testIgnored++;
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/RunWithTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/RunWithTest.java
new file mode 100644
index 0000000..c41a40a
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/RunWithTest.java
@@ -0,0 +1,88 @@
+package org.junit.tests.running.classes;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runner.notification.RunNotifier;
+
+public class RunWithTest {
+
+    private static String log;
+
+    public static class ExampleRunner extends Runner {
+        public ExampleRunner(Class<?> klass) {
+            log += "initialize";
+        }
+
+        @Override
+        public void run(RunNotifier notifier) {
+            log += "run";
+        }
+
+        @Override
+        public int testCount() {
+            log += "count";
+            return 0;
+        }
+
+        @Override
+        public Description getDescription() {
+            log += "plan";
+            return Description.createSuiteDescription("example");
+        }
+    }
+
+    @RunWith(ExampleRunner.class)
+    public static class ExampleTest {
+    }
+
+    @Test
+    public void run() {
+        log = "";
+
+        JUnitCore.runClasses(ExampleTest.class);
+        assertTrue(log.contains("plan"));
+        assertTrue(log.contains("initialize"));
+        assertTrue(log.contains("run"));
+    }
+
+    public static class SubExampleTest extends ExampleTest {
+    }
+
+    @Test
+    public void runWithExtendsToSubclasses() {
+        log = "";
+
+        JUnitCore.runClasses(SubExampleTest.class);
+        assertTrue(log.contains("run"));
+    }
+
+    public static class BadRunner extends Runner {
+        @Override
+        public Description getDescription() {
+            return null;
+        }
+
+        @Override
+        public void run(RunNotifier notifier) {
+            // do nothing
+        }
+    }
+
+    @RunWith(BadRunner.class)
+    public static class Empty {
+    }
+
+    @Test
+    public void characterizeErrorMessageFromBadRunner() {
+        assertEquals(
+                "Custom runner class BadRunner should have a public constructor with signature BadRunner(Class testClass)",
+                JUnitCore.runClasses(Empty.class).getFailures().get(0)
+                        .getMessage());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/SuiteTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/SuiteTest.java
new file mode 100644
index 0000000..42b492e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/SuiteTest.java
@@ -0,0 +1,218 @@
+package org.junit.tests.running.classes;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import java.util.List;
+
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.TestResult;
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runner.Runner;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+public class SuiteTest {
+    public static class TestA {
+        @Test
+        public void pass() {
+        }
+    }
+
+    public static class TestB {
+        @Test
+        public void fail() {
+            Assert.fail();
+        }
+    }
+
+    @RunWith(Suite.class)
+    @SuiteClasses({TestA.class, TestB.class})
+    public static class All {
+    }
+
+    @RunWith(Suite.class)
+    @SuiteClasses(TestA.class)
+    static class NonPublicSuite {
+    }
+
+    @RunWith(Suite.class)
+    @SuiteClasses(TestA.class)
+    static class NonPublicSuiteWithBeforeClass {
+        @BeforeClass
+        public static void doesNothing() {}
+    }
+
+    public static class InheritsAll extends All {
+    }
+
+    @Test
+    public void ensureTestIsRun() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(All.class);
+        assertEquals(2, result.getRunCount());
+        assertEquals(1, result.getFailureCount());
+    }
+
+    @Test
+    public void ensureInheritedTestIsRun() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(InheritsAll.class);
+        assertEquals(2, result.getRunCount());
+        assertEquals(1, result.getFailureCount());
+    }
+
+    @Test
+    public void suiteTestCountIsCorrect() throws Exception {
+        Runner runner = Request.aClass(All.class).getRunner();
+        assertEquals(2, runner.testCount());
+    }
+
+    @Test
+    public void suiteClassDoesNotNeedToBePublic() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(NonPublicSuite.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(0, result.getFailureCount());
+    }
+
+    @Test
+    public void nonPublicSuiteClassWithBeforeClassPasses() {
+        assertThat(testResult(NonPublicSuiteWithBeforeClass.class), isSuccessful());
+    }
+
+    @Test
+    public void ensureSuitesWorkWithForwardCompatibility() {
+        junit.framework.Test test = new JUnit4TestAdapter(All.class);
+        TestResult result = new TestResult();
+        test.run(result);
+        assertEquals(2, result.runCount());
+    }
+
+    @Test
+    public void forwardCompatibilityWorksWithGetTests() {
+        JUnit4TestAdapter adapter = new JUnit4TestAdapter(All.class);
+        List<? extends junit.framework.Test> tests = adapter.getTests();
+        assertEquals(2, tests.size());
+    }
+
+    @Test
+    public void forwardCompatibilityWorksWithTestCount() {
+        JUnit4TestAdapter adapter = new JUnit4TestAdapter(All.class);
+        assertEquals(2, adapter.countTestCases());
+    }
+
+
+    private static String log = "";
+
+    @RunWith(Suite.class)
+    @SuiteClasses({TestA.class, TestB.class})
+    public static class AllWithBeforeAndAfterClass {
+        @BeforeClass
+        public static void before() {
+            log += "before ";
+        }
+
+        @AfterClass
+        public static void after() {
+            log += "after ";
+        }
+    }
+
+    @Test
+    public void beforeAndAfterClassRunOnSuite() {
+        log = "";
+        JUnitCore.runClasses(AllWithBeforeAndAfterClass.class);
+        assertEquals("before after ", log);
+    }
+
+    @RunWith(Suite.class)
+    public static class AllWithOutAnnotation {
+    }
+
+    @Test
+    public void withoutSuiteClassAnnotationProducesFailure() {
+        Result result = JUnitCore.runClasses(AllWithOutAnnotation.class);
+        assertEquals(1, result.getFailureCount());
+        String expected = String.format(
+                "class '%s' must have a SuiteClasses annotation",
+                AllWithOutAnnotation.class.getName());
+        assertEquals(expected, result.getFailures().get(0).getMessage());
+    }
+
+    @RunWith(Suite.class)
+    @SuiteClasses(InfiniteLoop.class)
+    static public class InfiniteLoop {
+    }
+
+    @Test
+    public void whatHappensWhenASuiteHasACycle() {
+        Result result = JUnitCore.runClasses(InfiniteLoop.class);
+        assertEquals(1, result.getFailureCount());
+    }
+
+    @RunWith(Suite.class)
+    @SuiteClasses({BiInfiniteLoop.class, BiInfiniteLoop.class})
+    static public class BiInfiniteLoop {
+    }
+
+    @Test
+    public void whatHappensWhenASuiteHasAForkingCycle() {
+        Result result = JUnitCore.runClasses(BiInfiniteLoop.class);
+        assertEquals(2, result.getFailureCount());
+    }
+
+    // The interesting case here is that Hydra indirectly contains two copies of
+    // itself (if it only contains one, Java's StackOverflowError eventually
+    // bails us out)
+
+    @RunWith(Suite.class)
+    @SuiteClasses({Hercules.class})
+    static public class Hydra {
+    }
+
+    @RunWith(Suite.class)
+    @SuiteClasses({Hydra.class, Hydra.class})
+    static public class Hercules {
+    }
+
+    @Test
+    public void whatHappensWhenASuiteContainsItselfIndirectly() {
+        Result result = JUnitCore.runClasses(Hydra.class);
+        assertEquals(2, result.getFailureCount());
+    }
+
+    @RunWith(Suite.class)
+    @SuiteClasses({})
+    public class WithoutDefaultConstructor {
+        public WithoutDefaultConstructor(int i) {
+
+        }
+    }
+
+    @Test
+    public void suiteShouldBeOKwithNonDefaultConstructor() throws Exception {
+        Result result = JUnitCore.runClasses(WithoutDefaultConstructor.class);
+        assertTrue(result.wasSuccessful());
+    }
+
+    @RunWith(Suite.class)
+    public class NoSuiteClassesAnnotation {
+    }
+
+    @Test
+    public void suiteShouldComplainAboutNoSuiteClassesAnnotation() {
+        assertThat(testResult(NoSuiteClassesAnnotation.class), hasSingleFailureContaining("SuiteClasses"));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ThreadsTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ThreadsTest.java
new file mode 100644
index 0000000..2965187
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/ThreadsTest.java
@@ -0,0 +1,83 @@
+package org.junit.tests.running.classes;
+
+import org.junit.AfterClass;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runner.notification.RunListener;
+import org.junit.runners.BlockJUnit4ClassRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static org.junit.Assert.assertEquals;
+
+public class ThreadsTest {
+
+    private List<Boolean> interruptedFlags = new ArrayList<Boolean>();
+    private JUnitCore core = new JUnitCore();
+
+    public static class TestWithInterrupt {
+
+        @Test
+        public void interruptCurrentThread() {
+            Thread.currentThread().interrupt();
+        }
+
+        @Test
+        public void otherTestCaseInterruptingCurrentThread() {
+            Thread.currentThread().interrupt();
+        }
+
+    }
+
+    @Test
+    public void currentThreadInterruptedStatusIsClearedAfterEachTestExecution() {
+        core.addListener(new RunListener() {
+            @Override
+            public void testFinished(Description description) {
+                interruptedFlags.add(Thread.currentThread().isInterrupted());
+            }
+        });
+
+        Result result = core.run(TestWithInterrupt.class);
+
+        assertEquals(0, result.getFailureCount());
+        assertEquals(asList(false, false), interruptedFlags);
+    }
+
+    @RunWith(BlockJUnit4ClassRunner.class)
+    public static class TestWithInterruptFromAfterClass {
+        @AfterClass
+        public static void interruptCurrentThread() {
+            Thread.currentThread().interrupt();
+        }
+
+        @Test
+        public void test() {
+            // no-op
+        }
+    }
+
+    @Test
+    public void currentThreadInterruptStatusIsClearedAfterSuiteExecution() {
+        core.addListener(new RunListener() {
+            @Override
+            public void testSuiteFinished(Description description) {
+                interruptedFlags.add(Thread.currentThread().isInterrupted());
+            }
+        });
+
+        Request request = Request.aClass(TestWithInterruptFromAfterClass.class);
+
+        Result result = core.run(request);
+
+        assertEquals(0, result.getFailureCount());
+        assertEquals(singletonList(false), interruptedFlags);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/UseSuiteAsASuperclassTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/UseSuiteAsASuperclassTest.java
new file mode 100644
index 0000000..c55a8ab
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/UseSuiteAsASuperclassTest.java
@@ -0,0 +1,45 @@
+package org.junit.tests.running.classes;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.model.InitializationError;
+
+public class UseSuiteAsASuperclassTest {
+
+    public static class TestA {
+        @Test
+        public void pass() {
+        }
+    }
+
+    public static class TestB {
+        @Test
+        public void dontPass() {
+            fail();
+        }
+    }
+
+    public static class MySuite extends Suite {
+        public MySuite(Class<?> klass) throws InitializationError {
+            super(klass, new Class[]{TestA.class, TestB.class});
+        }
+    }
+
+    @RunWith(MySuite.class)
+    public static class AllWithMySuite {
+    }
+
+    @Test
+    public void ensureTestsAreRun() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(AllWithMySuite.class);
+        assertEquals(2, result.getRunCount());
+        assertEquals(1, result.getFailureCount());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/parent/ParentRunnerClassLoaderTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/parent/ParentRunnerClassLoaderTest.java
new file mode 100644
index 0000000..1644336
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/parent/ParentRunnerClassLoaderTest.java
@@ -0,0 +1,94 @@
+package org.junit.tests.running.classes.parent;
+
+import static org.junit.Assert.assertEquals;
+
+import java.lang.reflect.Field;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.ParentRunner;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+
+public class ParentRunnerClassLoaderTest {
+    @Test
+    public void testClassRuleAccessToClassInAnotherClassLoader() throws Exception {
+        Class<?> testClassWithOwnClassLoader = wrapToClassLoader(TestWithClassRule.class);
+
+        runTestWithParentRunner(testClassWithOwnClassLoader);
+
+        Field fieldWithReference = testClassWithOwnClassLoader.getDeclaredField("applyTestClass");
+        Class<?> usedClass = (Class<?>) fieldWithReference.get(null);
+
+        assertEquals("JUnitRunner can be located in own classLoader, so, " +
+                        "Class.forName org.junit.runner.Description.getTestClass can not see " +
+                        "in current classloader by execute Class.forName",
+                testClassWithOwnClassLoader, usedClass
+        );
+    }
+
+    @Test
+    public void testDescriptionContainCorrectTestClass() throws Exception {
+        Class<?> testClassWithOwnClassLoader = wrapToClassLoader(TestWithClassRule.class);
+        ParentRunner<?> runner = new BlockJUnit4ClassRunner(testClassWithOwnClassLoader);
+
+        Description description = runner.getDescription();
+        assertEquals("ParentRunner accept already instantiate Class<?> with tests, if we lost it instance, and will " +
+                "use Class.forName we can not find test class again, because tests can be " +
+                "located in different ClassLoader",
+                description.getTestClass(), testClassWithOwnClassLoader
+        );
+    }
+
+    @Test
+    public void testBackwardCompatibilityWithOverrideGetName() throws Exception {
+        final Class<TestWithClassRule> originalTestClass = TestWithClassRule.class;
+        final Class<?> waitClass = ParentRunnerClassLoaderTest.class;
+
+        ParentRunner<FrameworkMethod> subParentRunner = new BlockJUnit4ClassRunner(originalTestClass) {
+            @Override
+            protected String getName() {
+                return waitClass.getName();
+            }
+        };
+
+        Description description = subParentRunner.getDescription();
+        Class<?> result = description.getTestClass();
+
+        assertEquals("Subclass of ParentRunner can override getName method and specify another test class for run, " +
+                "we should  maintain backwards compatibility with JUnit 4.12",
+                waitClass, result
+        );
+    }
+
+    private void runTestWithParentRunner(Class<?> testClass) throws InitializationError {
+        ParentRunner<?> runner = new BlockJUnit4ClassRunner(testClass);
+        runner.run(new RunNotifier());
+    }
+
+    private Class<?> wrapToClassLoader(Class<?> sourceClass) throws ClassNotFoundException {
+        URL classpath = sourceClass.getProtectionDomain().getCodeSource().getLocation();
+        VisibleClassLoader loader = new VisibleClassLoader(new URL[]{classpath}, this.getClass().getClassLoader());
+        Class<?> testClassWithOwnClassLoader = loader.findClass(sourceClass.getName());
+
+        assert testClassWithOwnClassLoader != sourceClass;
+
+        return testClassWithOwnClassLoader;
+    }
+
+
+    private static class VisibleClassLoader extends URLClassLoader {
+        public VisibleClassLoader(URL[] urls, ClassLoader parent) {
+            super(urls, parent);
+        }
+
+        @Override // just making public
+        public Class<?> findClass(String name) throws ClassNotFoundException {
+            return super.findClass(name);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/parent/TestWithClassRule.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/parent/TestWithClassRule.java
new file mode 100644
index 0000000..62c892c
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/classes/parent/TestWithClassRule.java
@@ -0,0 +1,42 @@
+package org.junit.tests.running.classes.parent;
+
+import org.junit.Assert;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+import java.lang.reflect.Field;
+
+/**
+ * Test class for validate run tests that was load in own ClassLoader
+ */
+public class TestWithClassRule {
+    public static Class<?> applyTestClass;
+
+    @ClassRule
+    public static TestRule rule = new CustomRule();
+
+    @Test
+    public void testClassRuleExecuted() throws Exception {
+        Assert.assertNotNull("Description should contain reference to TestClass", applyTestClass);
+    }
+
+    public static final class CustomRule implements TestRule {
+
+        public Statement apply(final Statement base, final Description description) {
+            return new Statement() {
+                @Override
+                public void evaluate() throws Throwable {
+                    Class<?> testClass = description.getTestClass();
+                    if(testClass != null) {
+                        Field field = testClass.getDeclaredField("applyTestClass");
+                        field.set(null, description.getTestClass());
+                    }
+                    base.evaluate();
+                }
+            };
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/AllCoreTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/AllCoreTests.java
new file mode 100644
index 0000000..a17a7e2
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/AllCoreTests.java
@@ -0,0 +1,14 @@
+package org.junit.tests.running.core;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        CommandLineTest.class,
+        JUnitCoreReturnsCorrectExitCodeTest.class,
+        SystemExitTest.class
+})
+public class AllCoreTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/CommandLineTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/CommandLineTest.java
new file mode 100644
index 0000000..37f0659
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/CommandLineTest.java
@@ -0,0 +1,78 @@
+package org.junit.tests.running.core;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+
+public class CommandLineTest {
+    private ByteArrayOutputStream results;
+    private PrintStream oldOut;
+    private static boolean testWasRun;
+
+    @Before
+    public void before() {
+        oldOut = System.out;
+        results = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(results));
+    }
+
+    @After
+    public void after() {
+        System.setOut(oldOut);
+    }
+
+    public static class Example {
+        @Test
+        public void test() {
+            testWasRun = true;
+        }
+    }
+
+    @Test
+    public void runATest() {
+        testWasRun = false;
+        new MainRunner().runWithCheckForSystemExit(new Runnable() {
+            public void run() {
+                JUnitCore.main("org.junit.tests.running.core.CommandLineTest$Example");
+            }
+        });
+        assertTrue(testWasRun);
+    }
+
+    @Test
+    public void runAClass() {
+        testWasRun = false;
+        JUnitCore.runClasses(Example.class);
+        assertTrue(testWasRun);
+    }
+
+    private static int fCount;
+
+    public static class Count {
+        @Test
+        public void increment() {
+            fCount++;
+        }
+    }
+
+    @Test
+    public void runTwoClassesAsArray() {
+        fCount = 0;
+        JUnitCore.runClasses(new Class[]{Count.class, Count.class});
+        assertEquals(2, fCount);
+    }
+
+    @Test
+    public void runTwoClasses() {
+        fCount = 0;
+        JUnitCore.runClasses(Count.class, Count.class);
+        assertEquals(2, fCount);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/JUnitCoreReturnsCorrectExitCodeTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/JUnitCoreReturnsCorrectExitCodeTest.java
new file mode 100644
index 0000000..64af301
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/JUnitCoreReturnsCorrectExitCodeTest.java
@@ -0,0 +1,47 @@
+package org.junit.tests.running.core;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+
+public class JUnitCoreReturnsCorrectExitCodeTest {
+
+    public static class Fail {
+        @Test
+        public void kaboom() {
+            fail();
+        }
+    }
+
+    @Test
+    public void failureCausesExitCodeOf1() throws Exception {
+        runClass(getClass().getName() + "$Fail", 1);
+    }
+
+    @Test
+    public void missingClassCausesExitCodeOf1() throws Exception {
+        runClass("Foo", 1);
+    }
+
+    public static class Succeed {
+        @Test
+        public void peacefulSilence() {
+        }
+    }
+
+    @Test
+    public void successCausesExitCodeOf0() throws Exception {
+        runClass(getClass().getName() + "$Succeed", 0);
+    }
+
+    private void runClass(final String className, int returnCode) {
+        Integer exitValue = new MainRunner().runWithCheckForSystemExit(new Runnable() {
+            public void run() {
+                JUnitCore.main(className);
+            }
+        });
+        assertEquals(Integer.valueOf(returnCode), exitValue);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/MainRunner.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/MainRunner.java
new file mode 100644
index 0000000..ea90886
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/MainRunner.java
@@ -0,0 +1,67 @@
+package org.junit.tests.running.core;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.security.Permission;
+
+public class MainRunner {
+    private static class ExitException extends SecurityException {
+        private static final long serialVersionUID = -9104651568237766642L;
+
+        private final int status;
+
+        public ExitException(int status) {
+            super("");
+            this.status = status;
+        }
+
+        public int getStatus() {
+            return status;
+        }
+    }
+
+    /**
+     * A {@code NoExitSecurityManager} throws a {@link ExitException} exception
+     * whenever {@link #checkExit(int)} is called; all other permissions are allowed.
+     */
+    public class NoExitSecurityManager extends SecurityManager {
+
+        @Override
+        public void checkExit(int status) {
+            throw new ExitException(status);
+        }
+
+        @Override
+        public void checkPermission(Permission perm) {
+            if (perm.getName().startsWith("exitVM")) {
+                super.checkPermission(perm);
+            }
+        }
+    }
+
+    /**
+     * Execute runnable.run(), preventing System.exit(). If System.exit() is called
+     * in runnable.run(), the value is returned. If System.exit()
+     * is not called, null is returned.
+     *
+     * @return null if System.exit() is not called, Integer.valueof(status) if not
+     */
+    public Integer runWithCheckForSystemExit(Runnable runnable) {
+        SecurityManager oldSecurityManager = System.getSecurityManager();
+        System.setSecurityManager(new NoExitSecurityManager());
+        PrintStream oldOut = System.out;
+
+        System.setOut(new PrintStream(new ByteArrayOutputStream()));
+        try {
+            runnable.run();
+            System.out.println("System.exit() not called, return null");
+            return null;
+        } catch (ExitException e) {
+            System.out.println("System.exit() called, value=" + e.getStatus());
+            return e.getStatus();
+        } finally {
+            System.setSecurityManager(oldSecurityManager);
+            System.setOut(oldOut);
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/SystemExitTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/SystemExitTest.java
new file mode 100644
index 0000000..3e2dc7c
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/core/SystemExitTest.java
@@ -0,0 +1,31 @@
+package org.junit.tests.running.core;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.InputStream;
+
+import org.junit.Test;
+
+// Make sure System.exit works as expected. We've had problems with this on some platforms.
+public class SystemExitTest {
+
+    private static final int EXIT_CODE = 5;
+
+    static public class Exit {
+        public static void main(String[] args) {
+            System.exit(EXIT_CODE);
+        }
+    }
+
+    @Test
+    public void failureCausesExitCodeOf1() throws Exception {
+        String java = System.getProperty("java.home") + File.separator + "bin" + File.separator + "java";
+        String classPath = getClass().getClassLoader().getResource(".").getFile() + File.pathSeparator + System.getProperty("java.class.path");
+        String[] cmd = {java, "-cp", classPath, getClass().getName() + "$Exit"};
+        Process process = Runtime.getRuntime().exec(cmd);
+        InputStream input = process.getInputStream();
+        while ((input.read()) != -1) ;
+        assertEquals(EXIT_CODE, process.waitFor());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/AllMethodsTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/AllMethodsTests.java
new file mode 100644
index 0000000..533bb5e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/AllMethodsTests.java
@@ -0,0 +1,17 @@
+package org.junit.tests.running.methods;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AnnotationTest.class,
+        ExpectedTest.class,
+        InheritedTestTest.class,
+        ParameterizedTestMethodTest.class,
+        TestMethodTest.class,
+        TimeoutTest.class
+})
+public class AllMethodsTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/AnnotationTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/AnnotationTest.java
new file mode 100644
index 0000000..0025178
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/AnnotationTest.java
@@ -0,0 +1,842 @@
+package org.junit.tests.running.methods;
+
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.experimental.results.PrintableResult.testResult;
+import static org.junit.experimental.results.ResultMatchers.isSuccessful;
+
+import java.util.Collection;
+import java.util.HashSet;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExternalResource;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+public class AnnotationTest extends TestCase {
+    static boolean run;
+
+    @Override
+    public void setUp() {
+        run = false;
+    }
+
+    public static class SimpleTest {
+        @Test
+        public void success() {
+            run = true;
+        }
+    }
+
+    public void testAnnotatedMethod() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        runner.run(SimpleTest.class);
+        assertTrue(run);
+    }
+
+    @RunWith(JUnit4.class)
+    public static class SimpleTestWithFutureProofExplicitRunner {
+        @Test
+        public void success() {
+            run = true;
+        }
+    }
+
+    public void testAnnotatedMethodWithFutureProofExplicitRunner() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        runner.run(SimpleTestWithFutureProofExplicitRunner.class);
+        assertTrue(run);
+    }
+
+    public static class SetupTest {
+        @Before
+        public void before() {
+            run = true;
+        }
+
+        @Test
+        public void success() {
+        }
+    }
+
+    public void testSetup() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        runner.run(SetupTest.class);
+        assertTrue(run);
+    }
+
+    public static class TeardownTest {
+        @After
+        public void after() {
+            run = true;
+        }
+
+        @Test
+        public void success() {
+        }
+    }
+
+    public void testTeardown() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        runner.run(TeardownTest.class);
+        assertTrue(run);
+    }
+
+    public static class FailureTest {
+        @Test
+        public void error() throws Exception {
+            org.junit.Assert.fail();
+        }
+    }
+
+    public void testRunFailure() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        Result result = runner.run(FailureTest.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(1, result.getFailureCount());
+        assertEquals(AssertionError.class, result.getFailures().get(0).getException().getClass());
+    }
+
+    public static class SetupFailureTest {
+        @Before
+        public void before() {
+            throw new Error();
+        }
+
+        @Test
+        public void test() {
+            run = true;
+        }
+    }
+
+    public void testSetupFailure() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result runner = core.run(SetupFailureTest.class);
+        assertEquals(1, runner.getRunCount());
+        assertEquals(1, runner.getFailureCount());
+        assertEquals(Error.class, runner.getFailures().get(0).getException().getClass());
+        assertFalse(run);
+    }
+
+    public static class TeardownFailureTest {
+        @After
+        public void after() {
+            throw new Error();
+        }
+
+        @Test
+        public void test() {
+        }
+    }
+
+    public void testTeardownFailure() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result runner = core.run(TeardownFailureTest.class);
+        assertEquals(1, runner.getRunCount());
+        assertEquals(1, runner.getFailureCount());
+        assertEquals(Error.class, runner.getFailures().get(0).getException().getClass());
+    }
+
+    public static class TestAndTeardownFailureTest {
+        @After
+        public void after() {
+            throw new Error("hereAfter");
+        }
+
+        @Test
+        public void test() throws Exception {
+            throw new Exception("inTest");
+        }
+    }
+
+    public void testTestAndTeardownFailure() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result runner = core.run(TestAndTeardownFailureTest.class);
+        assertEquals(1, runner.getRunCount());
+        assertEquals(2, runner.getFailureCount());
+        assertThat(runner.getFailures().toString(), allOf(containsString("hereAfter"), containsString("inTest")));
+    }
+
+    public static class TeardownAfterFailureTest {
+        @After
+        public void after() {
+            run = true;
+        }
+
+        @Test
+        public void test() throws Exception {
+            throw new Exception();
+        }
+    }
+
+    public void testTeardownAfterFailure() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        runner.run(TeardownAfterFailureTest.class);
+        assertTrue(run);
+    }
+
+    static int count;
+    static Collection<Object> tests;
+
+    public static class TwoTests {
+        @Test
+        public void one() {
+            count++;
+            tests.add(this);
+        }
+
+        @Test
+        public void two() {
+            count++;
+            tests.add(this);
+        }
+    }
+
+    public void testTwoTests() throws Exception {
+        count = 0;
+        tests = new HashSet<Object>();
+        JUnitCore runner = new JUnitCore();
+        runner.run(TwoTests.class);
+        assertEquals(2, count);
+        assertEquals(2, tests.size());
+    }
+
+    public static class OldTest extends TestCase {
+        public void test() {
+            run = true;
+        }
+    }
+
+    public void testOldTest() throws Exception {
+        JUnitCore runner = new JUnitCore();
+        runner.run(OldTest.class);
+        assertTrue(run);
+    }
+
+    public static class OldSuiteTest extends TestCase {
+        public void testOne() {
+            run = true;
+        }
+    }
+
+    public void testOldSuiteTest() throws Exception {
+        TestSuite suite = new TestSuite(OldSuiteTest.class);
+        JUnitCore runner = new JUnitCore();
+        runner.run(suite);
+        assertTrue(run);
+    }
+
+    public static class ExceptionTest {
+        @Test(expected = Error.class)
+        public void expectedException() {
+            throw new Error();
+        }
+    }
+
+    public void testException() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(ExceptionTest.class);
+        assertEquals(0, result.getFailureCount());
+    }
+
+    public static class NoExceptionTest {
+        @Test(expected = Error.class)
+        public void expectedException() {
+        }
+    }
+
+    public void testExceptionNotThrown() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(NoExceptionTest.class);
+        assertEquals(1, result.getFailureCount());
+        assertEquals("Expected exception: java.lang.Error", result.getFailures().get(0).getMessage());
+    }
+
+    public static class OneTimeSetup {
+        @BeforeClass
+        public static void once() {
+            count++;
+        }
+
+        @Test
+        public void one() {
+        }
+
+        @Test
+        public void two() {
+        }
+    }
+
+    public void testOneTimeSetup() throws Exception {
+        count = 0;
+        JUnitCore core = new JUnitCore();
+        core.run(OneTimeSetup.class);
+        assertEquals(1, count);
+    }
+
+    public static class OneTimeTeardown {
+        @AfterClass
+        public static void once() {
+            count++;
+        }
+
+        @Test
+        public void one() {
+        }
+
+        @Test
+        public void two() {
+        }
+    }
+
+    public void testOneTimeTeardown() throws Exception {
+        count = 0;
+        JUnitCore core = new JUnitCore();
+        core.run(OneTimeTeardown.class);
+        assertEquals(1, count);
+    }
+
+    static String log;
+
+    public static class OrderTest {
+        @BeforeClass
+        public static void onceBefore() {
+            log += "beforeClass ";
+        }
+
+        @Before
+        public void before() {
+            log += "before ";
+        }
+
+        @Test
+        public void test() {
+            log += "test ";
+        }
+
+        @After
+        public void after() {
+            log += "after ";
+        }
+
+        @AfterClass
+        public static void onceAfter() {
+            log += "afterClass ";
+        }
+    }
+
+    public void testOrder() throws Exception {
+        log = "";
+        JUnitCore core = new JUnitCore();
+        core.run(OrderTest.class);
+        assertEquals("beforeClass before test after afterClass ", log);
+    }
+
+    public static class NonStaticOneTimeSetup {
+        @BeforeClass
+        public void once() {
+        }
+
+        @Test
+        public void aTest() {
+        }
+    }
+
+    public void testNonStaticOneTimeSetup() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(NonStaticOneTimeSetup.class);
+        assertEquals(1, result.getFailureCount());
+    }
+
+    public static class ErrorInBeforeClass {
+        @BeforeClass
+        public static void before() throws Exception {
+            throw new Exception();
+        }
+
+        @Test
+        public void test() {
+            run = true;
+        }
+    }
+
+    public void testErrorInBeforeClass() throws Exception {
+        run = false;
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(ErrorInBeforeClass.class);
+        assertFalse(run);
+        assertEquals(1, result.getFailureCount());
+        Description description = result.getFailures().get(0).getDescription();
+        assertEquals(ErrorInBeforeClass.class.getName(), description.getDisplayName());
+    }
+
+    public static class ErrorInAfterClass {
+        @Test
+        public void test() {
+            run = true;
+        }
+
+        @AfterClass
+        public static void after() throws Exception {
+            throw new Exception();
+        }
+    }
+
+    public void testErrorInAfterClass() throws Exception {
+        run = false;
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(ErrorInAfterClass.class);
+        assertTrue(run);
+        assertEquals(1, result.getFailureCount());
+    }
+
+    static class SuperInheritance {
+        @BeforeClass
+        public static void beforeClassSuper() {
+            log += "Before class super ";
+        }
+
+        @AfterClass
+        public static void afterClassSuper() {
+            log += "After class super ";
+        }
+
+        @Before
+        public void beforeSuper() {
+            log += "Before super ";
+        }
+
+        @After
+        public void afterSuper() {
+            log += "After super ";
+        }
+    }
+
+    public static class SubInheritance extends SuperInheritance {
+        @BeforeClass
+        public static void beforeClassSub() {
+            log += "Before class sub ";
+        }
+
+        @AfterClass
+        public static void afterClassSub() {
+            log += "After class sub ";
+        }
+
+        @Before
+        public void beforeSub() {
+            log += "Before sub ";
+        }
+
+        @After
+        public void afterSub() {
+            log += "After sub ";
+        }
+
+        @Test
+        public void test() {
+            log += "Test ";
+        }
+    }
+
+    public void testOrderingOfInheritance() throws Exception {
+        log = "";
+        JUnitCore core = new JUnitCore();
+        core.run(SubInheritance.class);
+        assertEquals("Before class super Before class sub Before super Before sub Test After sub After super After class sub After class super ", log);
+    }
+
+    public abstract static class SuperShadowing {
+
+        @Rule
+        public TestRule rule() {
+            return new ExternalResource() {
+                @Override
+                protected void before() throws Throwable {
+                    log += "super.rule().before() ";
+                }
+
+                @Override
+                protected void after() {
+                    log += "super.rule().after() ";
+                }
+            };
+        }
+
+        @Before
+        public void before() {
+            log += "super.before() ";
+        }
+
+        @After
+        public void after() {
+            log += "super.after() ";
+        }
+    }
+
+    public static class SubShadowing extends SuperShadowing {
+
+        @Override
+        @Rule
+        public TestRule rule() {
+            return new ExternalResource() {
+                @Override
+                protected void before() throws Throwable {
+                    log += "sub.rule().before() ";
+                }
+
+                @Override
+                protected void after() {
+                    log += "sub.rule().after() ";
+                }
+            };
+        }
+
+        @Override
+        @Before
+        public void before() {
+            super.before();
+            log += "sub.before() ";
+        }
+
+        @Before
+        public void anotherBefore() {
+            log += "sub.anotherBefore() ";
+        }
+
+        @Override
+        @After
+        public void after() {
+            log += "sub.after() ";
+            super.after();
+        }
+
+        @After
+        public void anotherAfter() {
+            log += "sub.anotherAfter() ";
+        }
+
+        @Test
+        public void test() {
+            log += "Test ";
+        }
+    }
+
+    public void testShadowing() throws Exception {
+        log = "";
+        assertThat(testResult(SubShadowing.class), isSuccessful());
+        assertEquals(
+                "sub.rule().before() sub.anotherBefore() super.before() sub.before() "
+                + "Test "
+                + "sub.anotherAfter() sub.after() super.after() sub.rule().after() ",
+                log);
+    }
+
+    public abstract static class SuperStaticMethodShadowing {
+
+        @ClassRule
+        public static TestRule rule() {
+            return new ExternalResource() {
+                @Override
+                protected void before() throws Throwable {
+                    log += "super.rule().before() ";
+                }
+
+                @Override
+                protected void after() {
+                    log += "super.rule().after() ";
+                }
+            };
+        }
+    }
+
+    public static class SubStaticMethodShadowing extends SuperStaticMethodShadowing {
+
+        @ClassRule
+        public static TestRule rule() {
+            return new ExternalResource() {
+                @Override
+                protected void before() throws Throwable {
+                    log += "sub.rule().before() ";
+                }
+
+                @Override
+                protected void after() {
+                    log += "sub.rule().after() ";
+                }
+            };
+        }
+
+        @Test
+        public void test() {
+            log += "Test ";
+        }
+    }
+
+    public void testStaticMethodsCanBeTreatedAsShadowed() throws Exception {
+        log = "";
+        assertThat(testResult(SubStaticMethodShadowing.class), isSuccessful());
+        assertEquals(
+                "sub.rule().before() "
+                + "Test "
+                + "sub.rule().after() ",
+                log);
+    }
+
+    public abstract static class SuperFieldShadowing {
+
+        @Rule
+        public final TestRule rule = new ExternalResource() {
+            @Override
+            protected void before() throws Throwable {
+                log += "super.rule.before() ";
+            }
+
+            @Override
+            protected void after() {
+                log += "super.rule.after() ";
+            }
+        };
+    }
+
+    public static class SubFieldShadowing extends SuperFieldShadowing {
+
+        @Rule
+        public final TestRule rule = new ExternalResource() {
+            @Override
+            protected void before() throws Throwable {
+                log += "sub.rule.before() ";
+            }
+
+            @Override
+            protected void after() {
+                log += "sub.rule.after() ";
+            }
+        };
+
+        @Test
+        public void test() {
+            log += "Test ";
+        }
+    }
+
+    public void testFieldsShadowFieldsFromParent() throws Exception {
+        log = "";
+        assertThat(testResult(SubFieldShadowing.class), isSuccessful());
+        assertEquals(
+                "sub.rule.before() "
+                + "Test "
+                + "sub.rule.after() ",
+                log);
+    }
+
+    public abstract static class SuperStaticFieldShadowing {
+
+        @ClassRule
+        public static TestRule rule = new ExternalResource() {
+            @Override
+            protected void before() throws Throwable {
+                log += "super.rule.before() ";
+            }
+
+            @Override
+            protected void after() {
+                log += "super.rule.after() ";
+            }
+        };
+    }
+
+    public static class SubStaticFieldShadowing extends SuperStaticFieldShadowing {
+
+        @ClassRule
+        public static TestRule rule = new ExternalResource() {
+            @Override
+            protected void before() throws Throwable {
+                log += "sub.rule.before() ";
+            }
+
+            @Override
+            protected void after() {
+                log += "sub.rule.after() ";
+            }
+        };
+
+        @Test
+        public void test() {
+            log += "Test ";
+        }
+    }
+
+    public void testStaticFieldsCanBeTreatedAsShadowed() throws Exception {
+        log = "";
+        assertThat(testResult(SubStaticFieldShadowing.class), isSuccessful());
+        assertEquals(
+                "sub.rule.before() "
+                + "Test "
+                + "sub.rule.after() ",
+                log);
+    }
+
+    public static class SuperTest {
+        @Test
+        public void one() {
+            log += "Super";
+        }
+
+        @Test
+        public void two() {
+            log += "Two";
+        }
+    }
+
+    public static class SubTest extends SuperTest {
+        @Override
+        @Test
+        public void one() {
+            log += "Sub";
+        }
+    }
+
+    public void testTestInheritance() throws Exception {
+        log = "";
+        JUnitCore core = new JUnitCore();
+        core.run(SubTest.class);
+        // The order in which the test methods are called is unspecified
+        assertTrue(log.contains("Sub"));
+        assertTrue(log.contains("Two"));
+        assertFalse(log.contains("Super"));
+    }
+
+    public static class RunAllAfters {
+        @Before
+        public void good() {
+        }
+
+        @Before
+        public void bad() {
+            throw new Error();
+        }
+
+        @Test
+        public void empty() {
+        }
+
+        @After
+        public void one() {
+            log += "one";
+        }
+
+        @After
+        public void two() {
+            log += "two";
+        }
+    }
+
+    public void testRunAllAfters() {
+        log = "";
+        JUnitCore core = new JUnitCore();
+        core.run(RunAllAfters.class);
+        assertTrue(log.contains("one"));
+        assertTrue(log.contains("two"));
+    }
+
+    public static class RunAllAftersRegardless {
+        @Test
+        public void empty() {
+        }
+
+        @After
+        public void one() {
+            log += "one";
+            throw new Error();
+        }
+
+        @After
+        public void two() {
+            log += "two";
+            throw new Error();
+        }
+    }
+
+    public void testRunAllAftersRegardless() {
+        log = "";
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(RunAllAftersRegardless.class);
+        assertTrue(log.contains("one"));
+        assertTrue(log.contains("two"));
+        assertEquals(2, result.getFailureCount());
+    }
+
+    public static class RunAllAfterClasses {
+        @Before
+        public void good() {
+        }
+
+        @BeforeClass
+        public static void bad() {
+            throw new Error();
+        }
+
+        @Test
+        public void empty() {
+        }
+
+        @AfterClass
+        public static void one() {
+            log += "one";
+        }
+
+        @AfterClass
+        public static void two() {
+            log += "two";
+        }
+    }
+
+    public void testRunAllAfterClasses() {
+        log = "";
+        JUnitCore core = new JUnitCore();
+        core.run(RunAllAfterClasses.class);
+        assertTrue(log.contains("one"));
+        assertTrue(log.contains("two"));
+    }
+
+    public static class RunAllAfterClassesRegardless {
+        @Test
+        public void empty() {
+        }
+
+        @AfterClass
+        public static void one() {
+            log += "one";
+            throw new Error();
+        }
+
+        @AfterClass
+        public static void two() {
+            log += "two";
+            throw new Error();
+        }
+    }
+
+    public void testRunAllAfterClassesRegardless() {
+        log = "";
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(RunAllAfterClassesRegardless.class);
+        assertTrue(log.contains("one"));
+        assertTrue(log.contains("two"));
+        assertEquals(2, result.getFailureCount());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/ExpectedTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/ExpectedTest.java
new file mode 100644
index 0000000..90e55f3
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/ExpectedTest.java
@@ -0,0 +1,83 @@
+package org.junit.tests.running.methods;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+
+public class ExpectedTest {
+
+    public static class Expected {
+        @Test(expected = Exception.class)
+        public void expected() throws Exception {
+            throw new Exception();
+        }
+    }
+
+    @Test
+    public void expected() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(Expected.class);
+        assertTrue(result.wasSuccessful());
+    }
+
+    public static class Unexpected {
+        @Test(expected = Exception.class)
+        public void expected() throws Exception {
+            throw new Error();
+        }
+    }
+
+    @Test
+    public void unexpected() {
+        Result result = JUnitCore.runClasses(Unexpected.class);
+        Failure failure = result.getFailures().get(0);
+        String message = failure.getMessage();
+        assertTrue(message.contains("expected<java.lang.Exception> but was<java.lang.Error>"));
+        assertEquals(Error.class, failure.getException().getCause().getClass());
+    }
+
+    public static class NoneThrown {
+        @Test(expected = Exception.class)
+        public void nothing() {
+        }
+    }
+
+    @Test
+    public void noneThrown() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(NoneThrown.class);
+        assertFalse(result.wasSuccessful());
+        String message = result.getFailures().get(0).getMessage();
+        assertTrue(message.contains("Expected exception: java.lang.Exception"));
+    }
+
+    public static class ExpectSuperclass {
+        @Test(expected = RuntimeException.class)
+        public void throwsSubclass() {
+            throw new ClassCastException();
+        }
+    }
+
+    @Test
+    public void expectsSuperclass() {
+        assertTrue(new JUnitCore().run(ExpectSuperclass.class).wasSuccessful());
+    }
+
+    public static class ExpectAssumptionViolatedException {
+        @Test(expected = AssumptionViolatedException.class)
+        public void throwsAssumptionViolatedException() {
+            throw new AssumptionViolatedException("expected");
+        }
+    }
+
+    @Test
+    public void expectsAssumptionViolatedException() {
+        assertTrue(new JUnitCore().run(ExpectAssumptionViolatedException.class).wasSuccessful());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/InheritedTestTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/InheritedTestTest.java
new file mode 100644
index 0000000..53f858b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/InheritedTestTest.java
@@ -0,0 +1,39 @@
+package org.junit.tests.running.methods;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+
+public class InheritedTestTest {
+    public abstract static class Super {
+        @Test
+        public void nothing() {
+        }
+    }
+
+    public static class Sub extends Super {
+    }
+
+    @Test
+    public void subclassWithOnlyInheritedTestsRuns() {
+        Result result = JUnitCore.runClasses(Sub.class);
+        assertTrue(result.wasSuccessful());
+    }
+
+    public static class SubWithBefore extends Super {
+        @Before
+        public void gack() {
+            fail();
+        }
+    }
+
+    @Test
+    public void subclassWithInheritedTestAndOwnBeforeRunsBefore() {
+        assertFalse(JUnitCore.runClasses(SubWithBefore.class).wasSuccessful());
+    }
+} 
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/ParameterizedTestMethodTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/ParameterizedTestMethodTest.java
new file mode 100644
index 0000000..4e24958
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/ParameterizedTestMethodTest.java
@@ -0,0 +1,188 @@
+package org.junit.tests.running.methods;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import junit.framework.JUnit4TestAdapter;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.junit.runners.model.InitializationError;
+
+@RunWith(Parameterized.class)
+public class ParameterizedTestMethodTest {
+
+    @SuppressWarnings("all")
+    public static class EverythingWrong {
+        private EverythingWrong() {
+        }
+
+        @BeforeClass
+        public void notStaticBC() {
+        }
+
+        @BeforeClass
+        static void notPublicBC() {
+        }
+
+        @BeforeClass
+        public static int nonVoidBC() {
+            return 0;
+        }
+
+        @BeforeClass
+        public static void argumentsBC(int i) {
+        }
+
+        @BeforeClass
+        public static void fineBC() {
+        }
+
+        @AfterClass
+        public void notStaticAC() {
+        }
+
+        @AfterClass
+        static void notPublicAC() {
+        }
+
+        @AfterClass
+        public static int nonVoidAC() {
+            return 0;
+        }
+
+        @AfterClass
+        public static void argumentsAC(int i) {
+        }
+
+        @AfterClass
+        public static void fineAC() {
+        }
+
+        @After
+        public static void staticA() {
+        }
+
+        @After
+        void notPublicA() {
+        }
+
+        @After
+        public int nonVoidA() {
+            return 0;
+        }
+
+        @After
+        public void argumentsA(int i) {
+        }
+
+        @After
+        public void fineA() {
+        }
+
+        @Before
+        public static void staticB() {
+        }
+
+        @Before
+        void notPublicB() {
+        }
+
+        @Before
+        public int nonVoidB() {
+            return 0;
+        }
+
+        @Before
+        public void argumentsB(int i) {
+        }
+
+        @Before
+        public void fineB() {
+        }
+
+        @Test
+        public static void staticT() {
+        }
+
+        @Test
+        void notPublicT() {
+        }
+
+        @Test
+        public int nonVoidT() {
+            return 0;
+        }
+
+        @Test
+        public void argumentsT(int i) {
+        }
+
+        @Test
+        public void fineT() {
+        }
+    }
+
+    private Class<?> fClass;
+    private int fErrorCount;
+
+    public static class SuperWrong {
+        @Test
+        void notPublic() {
+        }
+    }
+
+    public static class SubWrong extends SuperWrong {
+        @Test
+        public void justFine() {
+        }
+    }
+
+    public static class SubShadows extends SuperWrong {
+        @Override
+        @Test
+        public void notPublic() {
+        }
+    }
+
+    public ParameterizedTestMethodTest(Class<?> class1, int errorCount) {
+        fClass = class1;
+        fErrorCount = errorCount;
+    }
+
+    @Parameters
+    public static Collection<Object[]> params() {
+        return Arrays.asList(new Object[][]{
+                {EverythingWrong.class, 1 + 4 * 5}, {SubWrong.class, 1},
+                {SubShadows.class, 0}});
+    }
+
+    private List<Throwable> validateAllMethods(Class<?> clazz) {
+        try {
+            new BlockJUnit4ClassRunner(clazz);
+        } catch (InitializationError e) {
+            return e.getCauses();
+        }
+        return Collections.emptyList();
+    }
+
+    @Test
+    public void testFailures() throws Exception {
+        List<Throwable> problems = validateAllMethods(fClass);
+        assertEquals(fErrorCount, problems.size());
+    }
+
+    public static junit.framework.Test suite() {
+        return new JUnit4TestAdapter(ParameterizedTestMethodTest.class);
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/TestMethodTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/TestMethodTest.java
new file mode 100644
index 0000000..69a437e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/TestMethodTest.java
@@ -0,0 +1,255 @@
+package org.junit.tests.running.methods;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collections;
+import java.util.List;
+
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.TestResult;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.InitializationError;
+
+public class TestMethodTest {
+
+    @SuppressWarnings("all")
+    public static class EverythingWrong {
+        private EverythingWrong() {
+        }
+
+        @BeforeClass
+        public void notStaticBC() {
+        }
+
+        @BeforeClass
+        static void notPublicBC() {
+        }
+
+        @BeforeClass
+        public static int nonVoidBC() {
+            return 0;
+        }
+
+        @BeforeClass
+        public static void argumentsBC(int i) {
+        }
+
+        @BeforeClass
+        public static void fineBC() {
+        }
+
+        @AfterClass
+        public void notStaticAC() {
+        }
+
+        @AfterClass
+        static void notPublicAC() {
+        }
+
+        @AfterClass
+        public static int nonVoidAC() {
+            return 0;
+        }
+
+        @AfterClass
+        public static void argumentsAC(int i) {
+        }
+
+        @AfterClass
+        public static void fineAC() {
+        }
+
+        @After
+        public static void staticA() {
+        }
+
+        @After
+        void notPublicA() {
+        }
+
+        @After
+        public int nonVoidA() {
+            return 0;
+        }
+
+        @After
+        public void argumentsA(int i) {
+        }
+
+        @After
+        public void fineA() {
+        }
+
+        @Before
+        public static void staticB() {
+        }
+
+        @Before
+        void notPublicB() {
+        }
+
+        @Before
+        public int nonVoidB() {
+            return 0;
+        }
+
+        @Before
+        public void argumentsB(int i) {
+        }
+
+        @Before
+        public void fineB() {
+        }
+
+        @Test
+        public static void staticT() {
+        }
+
+        @Test
+        void notPublicT() {
+        }
+
+        @Test
+        public int nonVoidT() {
+            return 0;
+        }
+
+        @Test
+        public void argumentsT(int i) {
+        }
+
+        @Test
+        public void fineT() {
+        }
+    }
+
+    @Test
+    public void testFailures() throws Exception {
+        List<Throwable> problems = validateAllMethods(EverythingWrong.class);
+        int errorCount = 1 + 4 * 5; // missing constructor plus four invalid methods for each annotation */
+        assertEquals(errorCount, problems.size());
+    }
+
+    static public class SuperWrong {
+        @Test
+        void notPublic() {
+        }
+    }
+
+    static public class SubWrong extends SuperWrong {
+        @Test
+        public void justFine() {
+        }
+    }
+
+    @Test
+    public void validateInheritedMethods() throws Exception {
+        List<Throwable> problems = validateAllMethods(SubWrong.class);
+        assertEquals(1, problems.size());
+    }
+
+    static public class SubShadows extends SuperWrong {
+        @Override
+        @Test
+        public void notPublic() {
+        }
+    }
+
+    @Test
+    public void dontValidateShadowedMethods() throws Exception {
+        List<Throwable> problems = validateAllMethods(SubShadows.class);
+        assertTrue(problems.isEmpty());
+    }
+
+    private List<Throwable> validateAllMethods(Class<?> clazz) {
+        try {
+            new BlockJUnit4ClassRunner(clazz);
+        } catch (InitializationError e) {
+            return e.getCauses();
+        }
+        return Collections.emptyList();
+    }
+
+    static public class IgnoredTest {
+        @Test
+        public void valid() {
+        }
+
+        @Ignore
+        @Test
+        public void ignored() {
+        }
+
+        @Ignore("For testing purposes")
+        @Test
+        public void withReason() {
+        }
+    }
+
+    @Test
+    public void ignoreRunner() {
+        JUnitCore runner = new JUnitCore();
+        Result result = runner.run(IgnoredTest.class);
+        assertEquals(2, result.getIgnoreCount());
+        assertEquals(1, result.getRunCount());
+    }
+
+    @Test
+    public void compatibility() {
+        TestResult result = new TestResult();
+        new JUnit4TestAdapter(IgnoredTest.class).run(result);
+        assertEquals(1, result.runCount());
+    }
+
+    public static class Confused {
+        @Test
+        public void a(Object b) {
+        }
+
+        @Test
+        public void a() {
+        }
+    }
+
+    @Test(expected = InitializationError.class)
+    public void overloaded() throws InitializationError {
+        new BlockJUnit4ClassRunner(Confused.class);
+    }
+
+    public static class ConstructorParameter {
+        public ConstructorParameter(Object something) {
+        }
+
+        @Test
+        public void a() {
+        }
+    }
+
+    @Test(expected = InitializationError.class)
+    public void constructorParameter() throws InitializationError {
+        new BlockJUnit4ClassRunner(ConstructorParameter.class);
+    }
+
+    public static class OnlyTestIsIgnored {
+        @Ignore
+        @Test
+        public void ignored() {
+        }
+    }
+
+    @Test
+    public void onlyIgnoredMethodsIsStillFineTestClass() {
+        Result result = JUnitCore.runClasses(OnlyTestIsIgnored.class);
+        assertEquals(0, result.getFailureCount());
+        assertEquals(1, result.getIgnoreCount());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/TimeoutTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/TimeoutTest.java
new file mode 100644
index 0000000..21095fd
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/running/methods/TimeoutTest.java
@@ -0,0 +1,334 @@
+package org.junit.tests.running.methods;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.concurrent.TimeUnit;
+
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.TestResult;
+import org.junit.After;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestRule;
+import org.junit.rules.Timeout;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+
+public class TimeoutTest {
+
+    public static class FailureWithTimeoutTest {
+        @Test(timeout = 1000)
+        public void failure() {
+            fail();
+        }
+    }
+
+    @Test
+    public void failureWithTimeout() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(FailureWithTimeoutTest.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(1, result.getFailureCount());
+        assertEquals(AssertionError.class, result.getFailures().get(0).getException().getClass());
+    }
+
+    public static class FailureWithTimeoutRunTimeExceptionTest {
+        @Test(timeout = 1000)
+        public void failure() {
+            throw new NullPointerException();
+        }
+    }
+
+    @Test
+    public void failureWithTimeoutRunTimeException() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(FailureWithTimeoutRunTimeExceptionTest.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(1, result.getFailureCount());
+        assertEquals(NullPointerException.class, result.getFailures().get(0).getException().getClass());
+    }
+
+    public static class SuccessWithTimeoutTest {
+        @Test(timeout = 1000)
+        public void success() {
+        }
+    }
+
+    @Test
+    public void successWithTimeout() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(SuccessWithTimeoutTest.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(0, result.getFailureCount());
+    }
+
+    public static class TimeoutFailureTest {
+        @Test(timeout = 100)
+        public void success() throws InterruptedException {
+            Thread.sleep(40000);
+        }
+    }
+
+    @Ignore("was breaking gump")
+    @Test
+    public void timeoutFailure() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(TimeoutFailureTest.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(1, result.getFailureCount());
+        assertEquals(InterruptedException.class, result.getFailures().get(0).getException().getClass());
+    }
+
+    public static class InfiniteLoopTest {
+        @Test(timeout = 100)
+        public void failure() {
+            infiniteLoop();
+        }
+
+        private void infiniteLoop() {
+            for (; ; ) {
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException e) {
+                }
+            }
+        }
+    }
+
+    @Test
+    public void infiniteLoop() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(InfiniteLoopTest.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(1, result.getFailureCount());
+        Throwable exception = result.getFailures().get(0).getException();
+        assertTrue(exception.getMessage().contains("test timed out after 100 milliseconds"));
+    }
+
+    public static class ImpatientLoopTest {
+        @Test(timeout = 1)
+        public void failure() {
+            infiniteLoop();
+        }
+
+        private void infiniteLoop() {
+            for (; ; ) ;
+        }
+    }
+
+    @Ignore("This breaks sporadically with time differences just slightly more than 200ms")
+    @Test
+    public void infiniteLoopRunsForApproximatelyLengthOfTimeout() throws Exception {
+        // "prime the pump": running these beforehand makes the runtimes more predictable
+        //                   (because of class loading?)
+        JUnitCore.runClasses(InfiniteLoopTest.class, ImpatientLoopTest.class);
+        long longTime = runAndTime(InfiniteLoopTest.class);
+        long shortTime = runAndTime(ImpatientLoopTest.class);
+        long difference = longTime - shortTime;
+        assertTrue(String.format("Difference was %sms", difference), difference < 200);
+    }
+
+    private long runAndTime(Class<?> clazz) {
+        JUnitCore core = new JUnitCore();
+        long startTime = System.currentTimeMillis();
+        core.run(clazz);
+        long totalTime = System.currentTimeMillis() - startTime;
+        return totalTime;
+    }
+
+    private String stackForException(Throwable exception) {
+        Writer buffer = new StringWriter();
+        PrintWriter writer = new PrintWriter(buffer);
+        exception.printStackTrace(writer);
+        return buffer.toString();
+    }
+    
+    @Test
+    public void stalledThreadAppearsInStackTrace() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(InfiniteLoopTest.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(1, result.getFailureCount());
+        Throwable exception = result.getFailures().get(0).getException();
+        assertThat(stackForException(exception), containsString("infiniteLoop")); // Make sure we have the stalled frame on the stack somewhere
+    }
+
+    public static class InfiniteLoopMultithreaded {
+        
+        private static class ThreadTest implements Runnable {
+            private boolean fStall;
+
+            public ThreadTest(boolean stall) {
+                fStall = stall;
+            }
+
+            public void run() {
+                if (fStall)
+                    for (; ; ) ;   
+                try {
+                    Thread.sleep(500);
+                } catch (InterruptedException e) {
+                }
+            }
+        }
+        
+        public void failure(boolean mainThreadStalls) throws Exception {
+            Thread t1 = new Thread(new ThreadTest(false), "timeout-thr1");
+            Thread t2 = new Thread(new ThreadTest(!mainThreadStalls), "timeout-thr2");
+            Thread t3 = new Thread(new ThreadTest(false), "timeout-thr3");
+            t1.start();
+            t2.start();
+            t3.start();
+            if (mainThreadStalls)
+                for (; ; ) ;
+            t1.join();
+            t2.join();
+            t3.join();
+        }
+   }
+    
+    public static class InfiniteLoopWithStuckThreadTest {
+        @Rule
+        public TestRule globalTimeout = Timeout.builder()
+            .withTimeout(100, TimeUnit.MILLISECONDS)
+            .withLookingForStuckThread(true)
+            .build();
+
+        @Test
+        public void failure() throws Exception {
+            (new InfiniteLoopMultithreaded()).failure(false);
+        }
+    }
+    
+    public static class InfiniteLoopStuckInMainThreadTest {
+        @Rule
+        public TestRule globalTimeout = Timeout.builder()
+            .withTimeout(100, TimeUnit.MILLISECONDS)
+            .withLookingForStuckThread(true)
+            .build();
+
+        @Test
+        public void failure() throws Exception {
+            (new InfiniteLoopMultithreaded()).failure(true);
+        }
+    }
+
+    @Test
+    public void timeoutFailureMultithreaded() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(InfiniteLoopWithStuckThreadTest.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(2, result.getFailureCount());
+        Throwable exception[] = new Throwable[2];
+        for (int i = 0; i < 2; i++)
+            exception[i] = result.getFailures().get(i).getException();
+        assertThat(exception[0].getMessage(), containsString("test timed out after 100 milliseconds"));
+        assertThat(stackForException(exception[0]), containsString("Thread.join"));
+        assertThat(exception[1].getMessage(), containsString("Appears to be stuck in thread timeout-thr2"));
+    }
+
+    @Test
+    public void timeoutFailureMultithreadedStuckInMain() throws Exception {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(InfiniteLoopStuckInMainThreadTest.class);
+        assertEquals(1, result.getRunCount());
+        assertEquals(1, result.getFailureCount());
+        Throwable exception = result.getFailures().get(0).getException();
+        assertThat(exception.getMessage(), containsString("test timed out after 100 milliseconds"));
+        assertThat(exception.getMessage(), not(containsString("Appears to be stuck")));
+    }
+
+    @Test
+    public void compatibility() {
+        TestResult result = new TestResult();
+        new JUnit4TestAdapter(InfiniteLoopTest.class).run(result);
+        assertEquals(1, result.errorCount());
+    }
+
+    public static class WillTimeOut {
+        static boolean afterWasCalled = false;
+
+        @Test(timeout = 1)
+        public void test() {
+            for (; ; ) {
+                try {
+                    Thread.sleep(10000);
+                } catch (InterruptedException e) {
+                    // ok, tests are over
+                }
+            }
+        }
+
+        @After
+        public void after() {
+            afterWasCalled = true;
+        }
+    }
+
+    @Test
+    public void makeSureAfterIsCalledAfterATimeout() {
+        JUnitCore.runClasses(WillTimeOut.class);
+        assertThat(WillTimeOut.afterWasCalled, is(true));
+    }
+
+    public static class TimeOutZero {
+        @Rule
+        public Timeout timeout = Timeout.seconds(0);
+
+        @Test
+        public void test() {
+            try {
+                Thread.sleep(200); // long enough to suspend thread execution
+            } catch (InterruptedException e) {
+                // Don't care
+            }
+        }
+    }
+
+    @Test
+    public void testZeroTimeoutIsIgnored() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(TimeOutZero.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("Test should not have failed", 0, result.getFailureCount());
+    }
+
+    private static class TimeoutSubclass extends Timeout {
+
+        public TimeoutSubclass(long timeout, TimeUnit timeUnit) {
+            super(timeout, timeUnit);
+        }
+
+        public long getTimeoutFromSuperclass(TimeUnit unit) {
+            return super.getTimeout(unit);
+        }
+    }
+
+    public static class TimeOutOneSecond {
+        @Rule
+        public TimeoutSubclass timeout = new TimeoutSubclass(1, TimeUnit.SECONDS);
+
+        @Test
+        public void test() {
+            assertEquals(1000, timeout.getTimeoutFromSuperclass(TimeUnit.MILLISECONDS));
+        }
+    }
+
+    @Test
+    public void testGetTimeout() {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(TimeOutOneSecond.class);
+        assertEquals("Should run the test", 1, result.getRunCount());
+        assertEquals("Test should not have failed", 0, result.getFailureCount());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/AllValidationTests.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/AllValidationTests.java
new file mode 100644
index 0000000..f04723e
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/AllValidationTests.java
@@ -0,0 +1,14 @@
+package org.junit.tests.validation;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        BadlyFormedClassesTest.class,
+        FailedConstructionTest.class,
+        ValidationTest.class
+})
+public class AllValidationTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/BadlyFormedClassesTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/BadlyFormedClassesTest.java
new file mode 100644
index 0000000..d35de2c
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/BadlyFormedClassesTest.java
@@ -0,0 +1,71 @@
+package org.junit.tests.validation;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.internal.runners.JUnit4ClassRunner;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.junit.runner.notification.Failure;
+
+@SuppressWarnings("deprecation")
+public class BadlyFormedClassesTest {
+    public static class FaultyConstructor {
+        public FaultyConstructor() throws Exception {
+            throw new Exception("Thrown during construction");
+        }
+
+        @Test
+        public void someTest() {
+            /*
+                * Empty test just to fool JUnit and IDEs into running this class as
+                * a JUnit test
+                */
+        }
+    }
+
+    @RunWith(JUnit4ClassRunner.class)
+    public static class BadBeforeMethodWithLegacyRunner {
+        @Before
+        void before() {
+
+        }
+
+        @Test
+        public void someTest() {
+        }
+    }
+
+    public static class NoTests {
+        // class without tests
+    }
+
+    @Test
+    public void constructorException() {
+        String message = exceptionMessageFrom(FaultyConstructor.class);
+        assertEquals("Thrown during construction", message);
+    }
+
+    @Test
+    public void noRunnableMethods() {
+        assertThat(exceptionMessageFrom(NoTests.class), containsString("No runnable methods"));
+    }
+
+    @Test
+    public void badBeforeMethodWithLegacyRunner() {
+        assertEquals("Method before should be public",
+                exceptionMessageFrom(BadBeforeMethodWithLegacyRunner.class));
+    }
+
+    private String exceptionMessageFrom(Class<?> testClass) {
+        JUnitCore core = new JUnitCore();
+        Result result = core.run(testClass);
+        Failure failure = result.getFailures().get(0);
+        String message = failure.getException().getMessage();
+        return message;
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/FailedConstructionTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/FailedConstructionTest.java
new file mode 100644
index 0000000..a7aa1a5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/FailedConstructionTest.java
@@ -0,0 +1,28 @@
+package org.junit.tests.validation;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+
+public class FailedConstructionTest {
+    public static class CantConstruct {
+        public CantConstruct() {
+            throw new RuntimeException();
+        }
+
+        @Test
+        public void foo() {
+        }
+    }
+
+    @Test
+    public void failedConstructionIsTestFailure() {
+        Result result = JUnitCore.runClasses(CantConstruct.class);
+        Failure failure = result.getFailures().get(0);
+        Description expected = Description.createTestDescription(CantConstruct.class, "foo");
+        Assert.assertEquals(expected, failure.getDescription());
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/ValidationTest.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/ValidationTest.java
new file mode 100644
index 0000000..7a81b50
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/ValidationTest.java
@@ -0,0 +1,42 @@
+package org.junit.tests.validation;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+
+public class ValidationTest {
+    public static class WrongBeforeClass {
+        @BeforeClass
+        protected int a() {
+            return 0;
+        }
+    }
+
+    @Test
+    public void initializationErrorIsOnCorrectClass() {
+        assertEquals(WrongBeforeClass.class.getName(),
+                Request.aClass(WrongBeforeClass.class).getRunner().getDescription().getDisplayName());
+    }
+
+    public static class NonStaticBeforeClass {
+        @BeforeClass
+        public void before() {
+        }
+
+        @Test
+        public void hereBecauseEveryTestClassNeedsATest() {
+        }
+    }
+
+    @Test
+    public void nonStaticBeforeClass() {
+        Result result = JUnitCore.runClasses(NonStaticBeforeClass.class);
+        assertThat(result.getFailures().get(0).getMessage(), containsString("Method before() should be static"));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/anotherpackage/Sub.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/anotherpackage/Sub.java
new file mode 100644
index 0000000..d02a39d
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/anotherpackage/Sub.java
@@ -0,0 +1,5 @@
+package org.junit.tests.validation.anotherpackage;
+
+public class Sub extends Super {
+
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/anotherpackage/Super.java b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/anotherpackage/Super.java
new file mode 100644
index 0000000..bfd193b
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/tests/validation/anotherpackage/Super.java
@@ -0,0 +1,9 @@
+package org.junit.tests.validation.anotherpackage;
+
+import org.junit.Test;
+
+class Super {
+    @Test
+    public void a() {
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/validator/AllValidatorTests.java b/google3/third_party/java_src/junit/test/java/org/junit/validator/AllValidatorTests.java
new file mode 100644
index 0000000..f9c1ca9
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/validator/AllValidatorTests.java
@@ -0,0 +1,14 @@
+package org.junit.validator;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+        AnnotationsValidatorTest.class,
+        AnnotationValidatorFactoryTest.class,
+        PublicClassValidatorTest.class
+})
+public class AllValidatorTests {
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/validator/AnnotationValidatorFactoryTest.java b/google3/third_party/java_src/junit/test/java/org/junit/validator/AnnotationValidatorFactoryTest.java
new file mode 100644
index 0000000..064d4a3
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/validator/AnnotationValidatorFactoryTest.java
@@ -0,0 +1,47 @@
+package org.junit.validator;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+public class AnnotationValidatorFactoryTest {
+
+    @Rule
+    public ExpectedException exception = ExpectedException.none();
+
+    @Test
+    public void createAnnotationValidator() {
+        ValidateWith validateWith = SampleAnnotationWithValidator.class.getAnnotation(ValidateWith.class);
+        AnnotationValidator annotationValidator = new AnnotationValidatorFactory().createAnnotationValidator(validateWith);
+        assertThat(annotationValidator, is(instanceOf(Validator.class)));
+    }
+
+    @ValidateWith(value = Validator.class)
+    public @interface SampleAnnotationWithValidator {
+    }
+
+    public static class Validator extends AnnotationValidator {
+    }
+
+    @Test
+    public void exceptionWhenAnnotationValidatorCantBeCreated() {
+        ValidateWith validateWith = SampleAnnotationWithValidatorThatThrowsException.class.getAnnotation(ValidateWith.class);
+        exception.expect(RuntimeException.class);
+        exception.expectMessage("Exception received when creating AnnotationValidator class " +
+                "org.junit.validator.AnnotationValidatorFactoryTest$ValidatorThatThrowsException");
+        new AnnotationValidatorFactory().createAnnotationValidator(validateWith);
+    }
+
+    @ValidateWith(value = ValidatorThatThrowsException.class)
+    public @interface SampleAnnotationWithValidatorThatThrowsException {
+    }
+
+    public static class ValidatorThatThrowsException extends AnnotationValidator {
+        public ValidatorThatThrowsException() throws InstantiationException {
+            throw new InstantiationException("Simulating exception in test");
+        }
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/validator/AnnotationsValidatorTest.java b/google3/third_party/java_src/junit/test/java/org/junit/validator/AnnotationsValidatorTest.java
new file mode 100644
index 0000000..0be3cec
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/validator/AnnotationsValidatorTest.java
@@ -0,0 +1,98 @@
+package org.junit.validator;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Collection;
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.runners.model.FrameworkField;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.TestClass;
+
+public class AnnotationsValidatorTest {
+    public static class ExampleAnnotationValidator extends AnnotationValidator {
+        private static final String ANNOTATED_METHOD_CALLED= "annotated method called";
+
+        private static final String ANNOTATED_FIELD_CALLED= "annotated field called";
+
+        private static final String ANNOTATED_CLASS_CALLED= "annotated class called";
+
+        @Override
+        public List<Exception> validateAnnotatedClass(TestClass testClass) {
+            return asList(new Exception(ANNOTATED_CLASS_CALLED));
+        }
+
+        @Override
+        public List<Exception> validateAnnotatedField(FrameworkField field) {
+            return asList(new Exception(ANNOTATED_FIELD_CALLED));
+        }
+
+        @Override
+        public List<Exception> validateAnnotatedMethod(FrameworkMethod method) {
+            return asList(new Exception(ANNOTATED_METHOD_CALLED));
+        }
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Inherited
+    @ValidateWith(ExampleAnnotationValidator.class)
+    public @interface ExampleAnnotationWithValidator {
+    }
+
+    public static class AnnotationValidatorMethodTest {
+        @ExampleAnnotationWithValidator
+        @Test
+        public void test() {
+        }
+    }
+
+    public static class AnnotationValidatorFieldTest {
+        @ExampleAnnotationWithValidator
+        private String field;
+
+        @Test
+        public void test() {
+        }
+    }
+
+    @ExampleAnnotationWithValidator
+    public static class AnnotationValidatorClassTest {
+        @Test
+        public void test() {
+        }
+    }
+
+    @Test
+    public void validatorIsCalledForAClass() {
+        assertClassHasFailureMessage(AnnotationValidatorClassTest.class,
+                ExampleAnnotationValidator.ANNOTATED_CLASS_CALLED);
+    }
+
+    @Test
+    public void validatorIsCalledForAMethod() {
+        assertClassHasFailureMessage(AnnotationValidatorMethodTest.class,
+                ExampleAnnotationValidator.ANNOTATED_METHOD_CALLED);
+    }
+
+    @Test
+    public void validatorIsCalledForAField() {
+        assertClassHasFailureMessage(AnnotationValidatorFieldTest.class,
+                ExampleAnnotationValidator.ANNOTATED_FIELD_CALLED);
+    }
+
+    private void assertClassHasFailureMessage(Class<?> klass,
+            String expectedFailure) {
+        AnnotationsValidator validator= new AnnotationsValidator();
+        Collection<Exception> errors= validator
+                .validateTestClass(new TestClass(klass));
+        assertThat(errors.size(), is(1));
+        assertThat(errors.iterator().next().getMessage(),
+                is(expectedFailure));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/java/org/junit/validator/PublicClassValidatorTest.java b/google3/third_party/java_src/junit/test/java/org/junit/validator/PublicClassValidatorTest.java
new file mode 100644
index 0000000..dfecbbc
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/java/org/junit/validator/PublicClassValidatorTest.java
@@ -0,0 +1,41 @@
+package org.junit.validator;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.runners.model.TestClass;
+
+public class PublicClassValidatorTest {
+    private final PublicClassValidator validator = new PublicClassValidator();
+
+    public static class PublicClass {
+
+    }
+
+    @Test
+    public void acceptsPublicClass() {
+        TestClass testClass = new TestClass(PublicClass.class);
+        List<Exception> validationErrors = validator
+                .validateTestClass(testClass);
+        assertThat(validationErrors,
+                is(equalTo(Collections.<Exception> emptyList())));
+    }
+
+    static class NonPublicClass {
+
+    }
+
+    @Test
+    public void rejectsNonPublicClass() {
+        TestClass testClass = new TestClass(NonPublicClass.class);
+        List<Exception> validationErrors = validator
+                .validateTestClass(testClass);
+        assertThat("Wrong number of errors.", validationErrors.size(),
+                is(equalTo(1)));
+    }
+}
diff --git a/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunAssumptionFailedResultCanBeReserialised_v4_12 b/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunAssumptionFailedResultCanBeReserialised_v4_12
new file mode 100644
index 0000000..5eb4ef9
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunAssumptionFailedResultCanBeReserialised_v4_12
Binary files differ
diff --git a/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunAssumptionFailedResultCanBeReserialised_v4_13 b/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunAssumptionFailedResultCanBeReserialised_v4_13
new file mode 100644
index 0000000..6fa2a06
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunAssumptionFailedResultCanBeReserialised_v4_13
Binary files differ
diff --git a/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunFailureResultCanBeReserialised_v4_12 b/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunFailureResultCanBeReserialised_v4_12
new file mode 100644
index 0000000..79d8c01
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunFailureResultCanBeReserialised_v4_12
Binary files differ
diff --git a/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunSuccessResultCanBeReserialised_v4_12 b/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunSuccessResultCanBeReserialised_v4_12
new file mode 100644
index 0000000..e5163d1
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunSuccessResultCanBeReserialised_v4_12
Binary files differ
diff --git a/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunSuccessResultCanBeReserialised_v4_13 b/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunSuccessResultCanBeReserialised_v4_13
new file mode 100644
index 0000000..6c3e1b3
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/resources/junit/tests/runner/testRunSuccessResultCanBeReserialised_v4_13
Binary files differ
diff --git a/google3/third_party/java_src/junit/test/resources/org/junit/assumptionViolatedExceptionWithValueAndMatcherCanBeReserialized_v4_13 b/google3/third_party/java_src/junit/test/resources/org/junit/assumptionViolatedExceptionWithValueAndMatcherCanBeReserialized_v4_13
new file mode 100644
index 0000000..1409545
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/resources/org/junit/assumptionViolatedExceptionWithValueAndMatcherCanBeReserialized_v4_13
Binary files differ
diff --git a/google3/third_party/java_src/junit/test/resources/org/junit/assumptionViolatedExceptionWithoutValueAndMatcherCanBeReserialized_v4_13 b/google3/third_party/java_src/junit/test/resources/org/junit/assumptionViolatedExceptionWithoutValueAndMatcherCanBeReserialized_v4_13
new file mode 100644
index 0000000..199c36d
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/resources/org/junit/assumptionViolatedExceptionWithoutValueAndMatcherCanBeReserialized_v4_13
Binary files differ
diff --git a/google3/third_party/java_src/junit/test/resources/org/junit/internal/arrayComparisonFailure_411 b/google3/third_party/java_src/junit/test/resources/org/junit/internal/arrayComparisonFailure_411
new file mode 100644
index 0000000..11fe0c5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/resources/org/junit/internal/arrayComparisonFailure_411
Binary files differ
diff --git a/google3/third_party/java_src/junit/test/resources/org/junit/internal/arrayComparisonFailure_412 b/google3/third_party/java_src/junit/test/resources/org/junit/internal/arrayComparisonFailure_412
new file mode 100644
index 0000000..11fe0c5
--- /dev/null
+++ b/google3/third_party/java_src/junit/test/resources/org/junit/internal/arrayComparisonFailure_412
Binary files differ