Internal change PiperOrigin-RevId: 405717262 Change-Id: Ia055c28b59dae6447d37f408fcab1813f3836cb7
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>@After</code> causes that method to be run after the {@link org.junit.Test} method. All <code>@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>@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; + * @Before public void createOutputFile() { + * output= new File(...); + * } + * @Test public void something() { + * ... + * } + * @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>@AfterClass</code> causes that method to be run after all the tests in the class have been run. All <code>@AfterClass</code> + * methods are guaranteed to run even if a {@link org.junit.BeforeClass} method throws an + * exception. The <code>@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; + * @BeforeClass public static void login() { + * database= ...; + * } + * @Test public void something() { + * ... + * } + * @Test public void somethingElse() { + * ... + * } + * @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 <1> + * // got value: <0> + * 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<T></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("Help! Integers don't work", 0, is(1)); // fails: + * // failure message: + * // Help! Integers don't work + * // expected: is <1> + * // got value: <0> + * assertThat("Zero is one", 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<T></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>@Before</code> causes that method to be run before the {@link org.junit.Test} method. + * The <code>@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; + * @Before public void initialize() { + * empty= new ArrayList(); + * } + * @Test public void size() { + * ... + * } + * @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 { + * @BeforeClass public static void onlyOnce() { + * ... + * } + * @Test public void one() { + * ... + * } + * @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> + * @RunWith(Suite.class) + * @SuiteClasses({A.class, B.class, C.class}) + * public class UsesExternalResource { + * public static Server myServer= new Server(); + * + * @ClassRule + * public static ExternalResource resource= new ExternalResource() { + * @Override + * protected void before() throws Throwable { + * myServer.connect(); + * } + * + * @Override + * protected void after() { + * myServer.disconnect(); + * } + * }; + * } + * </pre> + * <p> + * and the same using a method + * <pre> + * @RunWith(Suite.class) + * @SuiteClasses({A.class, B.class, C.class}) + * public class UsesExternalResource { + * public static Server myServer= new Server(); + * + * @ClassRule + * public static ExternalResource getResource() { + * return new ExternalResource() { + * @Override + * protected void before() throws Throwable { + * myServer.connect(); + * } + * + * @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 { + * @ClassRule(order = 0) + * public static LoggingRule outer = new LoggingRule("outer rule"); + * + * @ClassRule(order = 1) + * public static LoggingRule middle = new LoggingRule("middle rule"); + * + * @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> + * @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>@Ignore</code> will not be executed as tests. + * Also, you can annotate a class containing test methods with <code>@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> + * @Ignore @Test public void something() { ... + * </pre> + * @Ignore takes an optional default parameter if you want to record why a test is being ignored: + * <pre> + * @Ignore("not ready yet") @Test public void something() { ... + * </pre> + * @Ignore can also be applied to the test class: + * <pre> + * @Ignore public class IgnoreMe { + * @Test public void test1() { ... } + * @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 { + * @Rule + * public TemporaryFolder folder= new TemporaryFolder(); + * + * @Test + * public void testUsingTempFolder() throws IOException { + * File createdFile= folder.newFile("myfile.txt"); + * File createdFolder= folder.newFolder("subfolder"); + * // ... + * } + * } + * </pre> + * <p> + * And the same using a method. + * <pre> + * public static class HasTempFolder { + * private TemporaryFolder folder= new TemporaryFolder(); + * + * @Rule + * public TemporaryFolder getFolder() { + * return folder; + * } + * + * @Test + * public void testUsingTempFolder() throws IOException { + * File createdFile= folder.newFile("myfile.txt"); + * File createdFolder= folder.newFolder("subfolder"); + * // ... + * } + * } + * </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 { + * @Rule(order = 0) + * public LoggingRule outer = new LoggingRule("outer rule"); + * + * @Rule(order = 1) + * public LoggingRule middle = new LoggingRule("middle rule"); + * + * @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>@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> + * @Test(<b>expected=IndexOutOfBoundsException.class</b>) + * public void outOfBounds() { + * new ArrayList<Object>().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> + * @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> + * @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 { + * @Test + * 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) + * @IncludeCategory(SlowTests.class) + * @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> + * @RunWith(Categories.class) + * @IncludeCategory({FastTests.class, SmokeTests.class}) + * @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>"[included categories] - [excluded categories]"</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>"categories [all]"</tt> for all included categories and no excluded ones; + * <li> <tt>"categories [all] - [A, B]"</tt> for all included categories and given excluded ones; + * <li> <tt>"categories [A, B] - [C, D]"</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 { + * @Test + * public void a() { + * fail(); + * } + * + * @Category(SlowTests.class) + * @Test + * public void b() { + * } + * } + * + * @Category({SlowTests.class, FastTests.class}) + * public static class B { + * @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> + * @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 @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>@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 @FromDataPoints} + * annotation. + * <p> + * Parameters with no specified source (i.e. without @FromDataPoints or + * other {@link org.junit.experimental.theories.ParametersSuppliedBy + * @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> + * @DataPoint + * public static String dataPoint = "value"; + * + * @DataPoint("generated") + * public static String generatedDataPoint() { + * return "generated value"; + * } + * + * @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 @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>@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 @FromDataPoints} + * annotation. + * <p> + * Parameters with no specified source (i.e. without @FromDataPoints or + * other {@link org.junit.experimental.theories.ParametersSuppliedBy + * @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> + * @DataPoints + * public static String[] dataPoints = new String[] { ... }; + * + * @DataPoints + * public static String[] generatedDataPoints() { + * return new String[] { ... }; + * } + * + * @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 + * @Theory} method with <code>@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 + * @DataPoints annotation. + * <p> + * DataPoints without names will not be considered as values for any parameters + * annotated with @FromDataPoints. + * <pre> + * @DataPoints + * public static String[] unnamed = new String[] { ... }; + * + * @DataPoints("regexes") + * public static String[] regexStrings = new String[] { ... }; + * + * @DataPoints({"forMatching", "alphanumeric"}) + * public static String[] testStrings = new String[] { ... }; + * + * @Theory + * public void stringTheory(String param) { + * // This will be called with every value in 'regexStrings', + * // 'testStrings' and 'unnamed'. + * } + * + * @Theory + * public void regexTheory(@FromDataPoints("regexes") String regex, + * @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>@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> + * @Retention(RetentionPolicy.RUNTIME) + * <b>@ParametersSuppliedBy</b>(BetweenSupplier.class) + * public @interface Between { + * int first(); + * + * int last(); + * } + * + * public static class BetweenSupplier extends <b>ParameterSupplier</b> { + * @Override + * public List<<b>PotentialAssignment</b>> getValueSources(<b>ParameterSignature</b> sig) { + * List<<b>PotentialAssignment</b>> list = new ArrayList<PotentialAssignment>(); + * Between annotation = (Between) sig.getSupplierAnnotation(); + * + * for (int i = annotation.first(); i <= 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 @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 + * @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> + * @ParametersSuppliedBy(Supplier.class) + * public @interface SpecialParameter { } + * + * @Theory + * public void theoryMethod(@SpecialParameter String param) { + * ... + * } + * </pre> + * + * equivalent to: + * + * <pre> + * @Theory + * public void theoryMethod(@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>@Theory</b>. To create a data point you create a public + * field in your test class and mark it with <b>@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> + * + * @RunWith(<b>Theories.class</b>) + * public class UserTest { + * <b>@DataPoint</b> + * public static String GOOD_USERNAME = "optimus"; + * <b>@DataPoint</b> + * public static String USERNAME_WITH_SLASH = "optimus/prime"; + * + * <b>@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 @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> + * @Theory + * public void shouldPassForSomeInts(@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> + * @RunWith(MyRunner.class) + * public class MyTest { + * // some tests might go here + * + * public class MyMemberClass { + * @Test + * public void thisTestRunsWith_MyRunner() { + * // some test logic + * } + * + * // some more tests might go here + * } + * + * @RunWith(AnotherRunner.class) + * public class AnotherMemberClass { + * // some tests might go here + * + * public class DeepInnerClass { + * @Test + * public void thisTestRunsWith_AnotherRunner() { + * // some test logic + * } + * } + * + * public class DeepInheritedClass extends SuperTest { + * @Test + * public void thisTestRunsWith_SuperRunner() { + * // some test logic + * } + * } + * } + * } + * + * @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> + * @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 { + * + * @Rule + * public TestRule timeout = new DisableOnDebug(new Timeout(20)); + * + * @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 { + * @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")); + * collector.checkThat(getResult(), not(containsString("ERROR!"))); + * // 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 { + * @Rule + * public ExpectedException thrown = ExpectedException.none(); + * + * @Test + * public void throwsNothing() { + * // no exception expected, none thrown: passes. + * } + * + * @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> @Test + * public void throwsException() { + * thrown.expect(NullPointerException.class); + * thrown.expectMessage("happened"); + * throw new NullPointerException("What happened?"); + * }</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> @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> @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> @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 <= 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 <= 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> @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> @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> @Test + * public void throwsExceptionWhoseMessageContainsSpecificText() { + * thrown.expectMessage("happened"); + * throw new NullPointerException("What happened?"); + * }</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> @Test + * public void throwsExceptionWhoseMessageCompliesWithMatcher() { + * thrown.expectMessage(startsWith("What")); + * throw new NullPointerException("What happened?"); + * }</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> @Test + * public void throwsExceptionWhoseCauseCompliesWithMatcher() { + * NullPointerException expectedCause = new NullPointerException(); + * thrown.expectCause(is(expectedCause)); + * throw new IllegalArgumentException("What happened?", 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(); + * + * @Rule + * public ExternalResource resource= new ExternalResource() { + * @Override + * protected void before() throws Throwable { + * myServer.connect(); + * }; + * + * @Override + * protected void after() { + * myServer.disconnect(); + * }; + * }; + * + * @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 { + * @Rule + * public final TestRule extendedLogging = CompositeRules.extendedLogging(); + * + * @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(""); + * + * private static void logInfo(Description description, String status, long nanos) { + * String testName = description.getMethodName(); + * logger.info(String.format("Test %s %s, spent %d microseconds", + * testName, status, TimeUnit.NANOSECONDS.toMicros(nanos))); + * } + * + * @Rule + * public Stopwatch stopwatch = new Stopwatch() { + * @Override + * protected void succeeded(long nanos, Description description) { + * logInfo(description, "succeeded", nanos); + * } + * + * @Override + * protected void failed(long nanos, Throwable e, Description description) { + * logInfo(description, "failed", nanos); + * } + * + * @Override + * protected void skipped(long nanos, AssumptionViolatedException e, Description description) { + * logInfo(description, "skipped", nanos); + * } + * + * @Override + * protected void finished(long nanos, Description description) { + * logInfo(description, "finished", nanos); + * } + * }; + * + * @Test + * public void succeeds() { + * } + * + * @Test + * public void fails() { + * fail(); + * } + * + * @Test + * public void skips() { + * assumeTrue(false); + * } + * } + * </pre> + * + * An example to assert runtime: + * <pre> + * @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 { + * @Rule + * public TemporaryFolder folder= new TemporaryFolder(); + * + * @Test + * public void testUsingTempFolder() throws IOException { + * File createdFile= folder.newFile("myfile.txt"); + * File createdFolder= folder.newFolder("subfolder"); + * // ... + * } + * } + * </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> + * @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 { + * @Rule + * public TestName name= new TestName(); + * + * @Test + * public void testA() { + * assertEquals("testA", name.getMethodName()); + * } + * + * @Test + * public void testB() { + * assertEquals("testB", 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; + * + * @Rule(order = Integer.MIN_VALUE) + * public TestWatcher watchman= new TestWatcher() { + * @Override + * protected void failed(Throwable e, Description description) { + * watchedLog+= description + "\n"; + * } + * + * @Override + * protected void succeeded(Description description) { + * watchedLog+= description + " " + "success!\n"; + * } + * }; + * + * @Test + * public void fails() { + * fail(); + * } + * + * @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; + * + * @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() { + * } + * } + * </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 { + * + * @Rule + * public Timeout globalTimeout = Timeout.millis(20); + * + * @Test + * public void run1() throws InterruptedException { + * Thread.sleep(100); + * } + * + * @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(); + * + * @Rule + * public Verifier verifier = new Verifier() { + * @Override public void verify() { + * assertTrue(errorLog.isEmpty()); + * } + * } + * + * @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>@OrderWith</code> or extends a class annotated + * with <code>@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 -> + * a {@link org.junit.runner.Runner} is created for each class implied by the <code>Request</code> -> + * 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<Description> forward() { + * return new Comparator<Description>() { + * 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<Description> orderItems(Collection<Description> descriptions) { + * List<Description> ordered = new ArrayList<>(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>@RunWith</code> or extends a class annotated + * with <code>@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> + * @RunWith(Suite.class) + * @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> + * @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> + * @RunWith(Parameterized.class) + * public 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); + * } + * } + * </pre> + * <p> + * Each instance of <code>AdditionTest</code> will be constructed using the + * three-argument constructor and the data values in the + * <code>@Parameters</code> method. + * <p> + * In order that you can easily identify the individual tests, you may provide a + * name for the <code>@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> + * @RunWith(Parameterized.class) + * public 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 } }); + * } + * + * @Parameter(0) + * public int firstSummand; + * + * @Parameter(1) + * public int secondSummand; + * + * @Parameter(2) + * public int sum; + * + * @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>@Parameter</code> will be initialized + * with the data values in the <code>@Parameters</code> method. + * + * <p> + * The parameters can be provided as an array, too: + * + * <pre> + * @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> + * @Parameters + * public static Iterable<? extends Object> data() { + * return Arrays.asList("first test", "second test"); + * } + * </pre> + * <p> + * or + * <pre> + * @Parameters + * public static Object[] data() { + * return new Object[] { "first test", "second test" }; + * } + * </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> + * @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> + * @RunWith(Parameterized.class) + * @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>@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> + * @Parameters + * public static Iterable<? extends Object> data() { + * String os = System.getProperty("os.name").toLowerCase() + * Assume.assumeTrue(os.contains("win")); + * return Arrays.asList("first test", "second test"); + * } + * </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
