Questions are in attached file.

Question

Abhishek · Accepted Answer

44836 - BagPack/Screenshots/Test.png
 44836 - BagPack/Screenshots/Marker.png
 44836 - BagPack/Problem/pf2019assignment1-ty3klyyb.pdf
ABS (Automatic Backpack Service)
James Baumeister
Programming Fundamentals, SP5 2019
Assignment 1
August 11, 2019
1 Introduction
Figure 1: An idyllic life...
As a programmer, I sit at my desk and dream about my next outdoor adventure. Then I
watch YouTube videos of other people living out my dream adventure. Then I think, “maybe
if I just buy all of the gear that I need...”
When I spent a month camping, hiking, adventuring in the US, I used up just about all
of the baggage allowance I was allocated (3 x 23 kg!!) so that I could take over all my gear:
camping, cooking, hiking, climbing, etc, etc. Creating some contrived, arbitrary task for you
to solve with programming made me think of how great it would be to have some company
that just gives you a packed and ready to go bag to borrow for however long you’re planning
to hike1. The bag would contain everything you need, tailored to the number of days you
1If you can’t already tell, I like to joke around. Take the introduction as mostly silliness and the rest of
the assignment seriously
1
plan to be on the trail, what your sleeping and dietary needs are, and how much you can
comfortably carry.
This is where ABS comes in. ABS is an innovative and enterprising solution ready to
be pitched to your friendly, local venture-capitalist. Well, it’s almost ready. I need you, my
army of fledgling programmers to build it for me!
In this assignment, you will build a service that takes in my needs as a hiker, and builds
and packs the perfect backpack for my upcoming hike. Not only will I get a sweet prototype
that will bring me fame and funding, you will learn some very important programming
concepts such as OOP, array data structures, and debugging and testing.
Assignment Structure
The first important point to realise is that this assignment has been released before we have
covered some very important aspects of the Java language. Do not panic if you are confused
by this at first glance. We will cover, in great detail, all of the building blocks that you need
to complete this assignment. Also, do not worry about the large number of classes in the
project. You will only edit Backpack, read BackpackTest to understand how the methods
are tested, and run AssignmentMarker to get your marks. Take it slow, do not panic, and
solve each little problem in manageable chunks.
You will complete this assignment in a series of steps. It is important that you complete
these in order, as some components rely on others. For each component in each step there
are automated tests that you can use to track your progress. You will add your code to only
one class, Backpack. Within Backpack, you are free to add your own methods and fields, but
do not change any existing method prototypes or field definitions. A testing suite has been
provided for you to test the functionality of your classes. These tests will be used to mark
your assignment, but with altered values. This means that you cannot hard-code answers to
pass the tests. You must create your solution to pass the tests; that is, you cannot change
the tests to use your solution, even if your solution provides the correct answer.
Importing into eclipse
The assignment has been provided as an eclipse project. You just need to import the project
into an existing workspace. See Figure 2 for a visual guide. Make sure that your Java JDK
has been set, as well as the two jar files that you need for junit to function. This can be
found in Project → Properties → Java Build Path → Libraries. The jar files have been
provided within the project; there is no need to download any other version and doing so
may impact the testing environment.
ABS Package
In eclipse you will see that the source code is divided into two packages. The first and main
package is ABS and this contains all of the classes and enumerators that are required for the
ABS system to function. The only class that you can modify is the Backpack class. Take a
look at all of the other classes and enumerators, however, and be sure to note their instance
variables, constructors, and available methods. You will need to use most of these when
2
Figure 2: Importing the project through File → Import
coding your solutions. The ABS_System class has been included as a suggested place to test
your methods outside of the formal unit testing environment. Think of this class as scrap
paper in an exam; anything you write on it is not graded.
Testing Package
In this package are the classes that provide the testing environment that grades your solu-
tions. To run the assignment program and see your marks, run AssignmentMarker, which
has a main method. The tests that will be used to mark your final solution will have altered
values to the ones you have been given. This means that you cannot hard-code answers to
pass the tests.
The code in the testing classes may look very complex and confusing to you. That is
totally fine. Pay close attention only to the BackpackTest class. Each testing method
(marked with @Test) shows you how your method is being tested and what the test expects
you to do in order to pass. This method of testing is used in industry to ensure that methods
do exactly what they are designed to do.
3
Part A
If you try to run AssignmentMarker you will be greeted with many errors. Your first task
is to implement the missing methods in the Backpack class. In that class, you will see that
javadoc documentation has been provided. This should look something like this:
/**
* assignMeals
* This method will create all of the meals that the hiker needs
* and place it into the Meal array. It should take into account all of
* the rules and preferences, as described in the assignment
* specification.
* @param hp A HikerPreferences object
*/
This comment first tells you that you need to create a method called assignMeals. The
@param decorator tells you that it expects one argument, a HikerPreferences object named
hp. The lack of a @return decorator tells you that this method should be void. In other
words, it should return nothing. The rest of the comment will give you a brief description
of what the method is designed to do. See the relevant section of this document for a more
detailed description. At this point, you should just complete the method stub and return a
default value, if required. Once you have resolved all of the errors in the BackpackTest, you
will see that the ’No Errors’ test passes.
Part B
The next thing you should do is familiarise yourself with each of the included classes and
enumerators. The ABS package has four included enumerators:
• DaysOnTrail This enumerator represents the available options that ABS offers for
how long its customers can be on the trail. It also includes a method, getDays, which
returns the number of days as an integer value. Currently, ABS only caters for up to
three days.
• GearType (in the Gear class This enumerator represents all of the available types of
gear that ABS can provide.
• MealType (in the Meal class This enumerator represents all of the available types of
meals that ABS can provide.
• Weight This enumerator represents the category of weight for a particular item. It can
be applied to either Gear or Meal objects.
Aside from the Backpack class, which you will add to, the ABS package contains some
other useful classes. You should not modify any of these classes.
4
• Gear This class represents a single item of hiking gear. It contains a constructor that
takes two arguments, a GearType variable and a Weight variable. It also contains
various setter and getter variables and other methods overridden from Object. You
do not need to modify anything in this class, just be familiar with its content.
• HikerPreferences This class represents choices that a hiker makes regarding the
configuration of their backpack. It has a constructor that take a parameter of the
DaysOnTrail, and two Weight variables for their preference of gear and meal weights.
It also includes some getter and setter methods.
• Meal This class represents a single meal item. It contains a constructor that takes a
MealType parameter and also a Weight preference. Other than that, it has some getter
and setter methods and standard overridden methods from Object.
• StoreInventory This class represents the total inventory available for backpacks on
the ABS system. The constructor takes no arguments and calls the
ReadFromFile(String filename) method. The method reads in a text file and popu-
lates the gearItems instance variable with all of the Gear items that it reads. Creating
an object of this class into a variable (for example, called inventory) will allow you
to access the inventory Gear items like: inventory.gearItems;.
Part C
In this section you will complete all of the methods in the Backpack class. It is suggested
that you complete these in the order suggested here as some later methods rely on the earlier
ones functioning correctly. Remember that you are free to add private methods and instance
variables if you think they will help you in completing these methods.
Backpack constructor
Implement a constructor that takes no arguments. In other words, this constructor should
be the default. This default constructor should complete two tasks only. First, it should
instantiate the storeInventory instance variable with the inventory created by using the
StoreInventory class. Secondly, it should instantiate the zones array. The zones array is
a two-dimensional Gear array that provides an abstraction of a backpack and the zones in
which particular types of gear should be packed. The first dimension of the array should have
as many elements are there are available zones in Figure 3. The second dimension should be
an array that is capable of holding zero to many items of Gear, depending on whether there
are items that need to be packed into that zone.
addItem
This method should not return any value and take one argument, a single Gear object, and
append it to the gear instance variable (a Gear array). If the array is null, it should be
instantiated with a size of one and the Gear item added. Otherwise, the array should be
5
Figure 3: A visualisation of how the zones array abstracts a backpack’s packing zones
resized to accommodate the new item. The array should only be as large as needed. That
is, if there are five items of gear in the array, it should be of length five; there should be no
null array elements.
removeItem int
This method should not return any value and take one argument, a single int value. It
should remove a Gear item from the gear instance variable at the int index provided. In
other words, if 2 is provided as an argument, the Gear item at index 2 in the array should
be removed. The array should then be resized so that it is only the required size, with no
null elements.
removeItem Gear
This method should not return any value and take one argument, a single Gear object. This
method should remove a specific Gear item from the gear instance variable. It should then
6
resize the array so that it is only the required size, with no null elements. If there are
multiple of the Gear item in the array, only the first should be removed. If the given item
of gear is not in the array, the array should remain unchanged.
packBackpack
This method should not return any value and takes no arguments. It should place each
item of gear in the gear variable into the correct zones in the zones two-dimensional array,
depending on each piece of gear’s GearType. Refer to Figure 3 to know which gear types
belong in which zone. If a zone is unused, the array for that zone should remain null. For
example, sleeping gear is not needed for a single-day hike. So: zones[4] == null.
assignMeals
This method should not return any value and take one argument, a single HikerPreferences
object. This method populates the meals array with all the Meal objects a hiker needs. The
first consideration is that the meal Weight preference must be honoured. That is, if a hiker
wants low-weight food, all the meals must be low weight. The second consideration is the
number of DaysOnTrail. Two rules must be followed:
• For every day, lunch and a snack is required.
• For every night, dinner and breakfast is required.
As a hint, hp.daysOnTrail == DaysOnTrail.TWO means that there is one night and two
days.
You must create all the required Meal objects and place them into the meal array instance
variable. Order does not matter as the testing code sorts the array.
assignGear
This method should not return any value and take one argument, a single HikerPreferences
object. This method populates the gear array with all the Gear objects a hiker needs. There
are two main parts to correctly implementing this method.
Determine what is required
Based on the number of DaysOnTrail and preferred gear Weight, you should create a struc-
ture to hold what is required for the hiker’s trip. You should honour the hiker’s Weight pref-
erence for all items of Gear. The one exception is for water, which always has a Weight.HIGH
value. Also, cooking gear is required if, and only if, the food weight preference is Weight.LOW
and the hike is overnight. Importantly, your solution must allow for the possibility of all
meal and gear weights for all possible days on the trail, even if BackpackTest does not
specifically have a test for it. You can test these cases yourself. Only one of each required
gear type should be added to the array. For example, if there are two nights on the trail,
only one shelter is required. For another example, imagine that a single clothing gear item
7
contains all the required clothing; there is no need to include multiple clothing items. To
summarise, there are four rules you must follow:
• For every hike, clothing, rain jacket, and water is required.
• For overnight hikes, bedding, sleeping bag, and shelter is required.
• For overnight hikes with low-weight food, cooking gear is required.
• Water always has a high weight.
Retrieve from the store
Once you have determined the gear that the hiker requires, you must select the items from
the store inventory. You must look through the storeInventory array, select items that
you have determined are required, and place them into the gear variable. There may be
multiple of the same gear items in the store inventory. You should only include one in the
gear array. You do not need to consider the case where the store inventory does not contain
the item you need. Despite this, you must not skip this step. Your code will be manually
checked to ensure you complete it.
toString
This method should return a String and take no arguments. This method should provide
a printout of the backpack’s contents. The output should follow this style example:
Zone 0:
Gear{gearType=RAIN_JACKET, weight=HIGH}
Zone 1:
Gear{gearType=SHELTER, weight=HIGH}
Zone 2:
Gear{gearType=CLOTHING, weight=HIGH}
Zone 3:
Gear{gearType=COOKING, weight=HIGH}
Gear{gearType=WATER, weight=HIGH}
Zone 4:
Gear{gearType=BEDDING, weight=HIGH}
Gear{gearType=SLEEPING_BAG, weight=HIGH}
Importantly, the indentation is a tab character. There should also be no trailing whitespace.
If there is no gear in a particular zone, that zone should be omitted from the output.
8
Marking Scheme
The marking of this assignment is divided into two portions. The first 75% is awarded by
AssignmentMarker and speaks to the correctness of your method implementations. The
second 25% is awarded manually by the markers and takes into account your coding style
and consistency. See Table 1 to see how marks are rewarded. As a final reminder, remember
that just because the marking programs awards you full marks, make sure that you cover
alternative values, orders, days on the trail, weights, etc. The final marker program will test
with alternative values to ensure you are not hard-coding answers.
The style marks will specifically look at the following:
• Solution follows the assignment specification
• Clear and adequate commenting of all logic and code flow
• Consistency of indentation
• Consistency of curly brace usage
• Adherence to principles of DRY—don’t repeat yourself. Write reusable methods where
appropriate
Table 1: BackpackTest mark allocation
Test Marks
noErrors 6
constructor 5
addItem 8
removeItemInt 8
removeItemGear 5
packBackpack 8
assignMeals 12
assignGear 15
toString 8
Total: 75
9
https://en.wikipedia.org/wiki/Don%27t_repeat_yourself
		Introduction
 44836 - BagPack/Solution/PF_SP5_2019-Assignment1/PF_SP5_2019-Assignment1.userlibraries
 
   
     
  
   
     
  
 44836 - BagPack/Solution/PF_SP5_2019-Assignment1/PF_SP5_2019-Assignment1.iml
 
   
     
     
       
    
     
     
     
     
  
 44836 - BagPack/Solution/PF_SP5_2019-Assignment1/PF_SP5_2019-Assignment1.eml
 
	 
	 
	 
	 
		 
		 
	
 44836 - BagPack/Solution/PF_SP5_2019-Assignment1/junit-4.12.jar
META-INF/MANIFEST.MF
Manifest-Version: 1.0
Implementation-Vendor: JUnit
Implementation-Title: JUnit
Implementation-Version: 4.12
Implementation-Vendor-Id: junit
Built-By: jenkins
Build-Jdk: 1.6.0_45
Created-By: Apache Maven 3.0.4
Archiver-Version: Plexus Archiver
org/junit/ClassRule.class
package org.junit;
public abstract interface ClassRule extends annotation.Annotation {
}
org/junit/Assert.class
package org.junit;
public synchronized class Assert {
    protected void Assert();
    public static void assertTrue(String, boolean);
    public static void assertTrue(boolean);
    public static void assertFalse(String, boolean);
    public static void assertFalse(boolean);
    public static void fail(String);
    public static void fail();
    public static void assertEquals(String, Object, Object);
    private static boolean equalsRegardingNull(Object, Object);
    private static boolean isEquals(Object, Object);
    public static void assertEquals(Object, Object);
    public static void assertNotEquals(String, Object, Object);
    public static void assertNotEquals(Object, Object);
    private static void failEquals(String, Object);
    public static void assertNotEquals(String, long, long);
    public static void assertNotEquals(long, long);
    public static void assertNotEquals(String, double, double, double);
    public static void assertNotEquals(double, double, double);
    public static void assertNotEquals(float, float, float);
    public static void assertArrayEquals(String, Object[], Object[]) throws internal.ArrayComparisonFailure;
    public static void assertArrayEquals(Object[], Object[]);
    public static void assertArrayEquals(String, boolean[], boolean[]) throws internal.ArrayComparisonFailure;
    public static void assertArrayEquals(boolean[], boolean[]);
    public static void assertArrayEquals(String, byte[], byte[]) throws internal.ArrayComparisonFailure;
    public static void assertArrayEquals(byte[], byte[]);
    public static void assertArrayEquals(String, char[], char[]) throws internal.ArrayComparisonFailure;
    public static void assertArrayEquals(char[], char[]);
    public static void assertArrayEquals(String, short[], short[]) throws internal.ArrayComparisonFailure;
    public static void assertArrayEquals(short[], short[]);
    public static void assertArrayEquals(String, int[], int[]) throws internal.ArrayComparisonFailure;
    public static void assertArrayEquals(int[], int[]);
    public static void assertArrayEquals(String, long[], long[]) throws internal.ArrayComparisonFailure;
    public static void assertArrayEquals(long[], long[]);
    public static void assertArrayEquals(String, double[], double[], double) throws internal.ArrayComparisonFailure;
    public static void assertArrayEquals(double[], double[], double);
    public static void assertArrayEquals(String, float[], float[], float) throws internal.ArrayComparisonFailure;
    public static void assertArrayEquals(float[], float[], float);
    private static void internalArrayEquals(String, Object, Object) throws internal.ArrayComparisonFailure;
    public static void assertEquals(String, double, double, double);
    public static void assertEquals(String, float, float, float);
    public static void assertNotEquals(String, float, float, float);
    private static boolean doubleIsDifferent(double, double, double);
    private static boolean floatIsDifferent(float, float, float);
    public static void assertEquals(long, long);
    public static void assertEquals(String, long, long);
    public static void assertEquals(double, double);
    public static void assertEquals(String, double, double);
    public static void assertEquals(double, double, double);
    public static void assertEquals(float, float, float);
    public static void assertNotNull(String, Object);
    public static void assertNotNull(Object);
    public static void assertNull(String, Object);
    public static void assertNull(Object);
    private static void failNotNull(String, Object);
    public static void assertSame(String, Object, Object);
    public static void assertSame(Object, Object);
    public static void assertNotSame(String, Object, Object);
    public static void assertNotSame(Object, Object);
    private static void failSame(String);
    private static void failNotSame(String, Object, Object);
    private static void failNotEquals(String, Object, Object);
    static String format(String, Object, Object);
    private static String formatClassAndValue(Object, String);
    public static void assertEquals(String, Object[], Object[]);
    public static void assertEquals(Object[], Object[]);
    public static void assertThat(Object, org.hamcrest.Matcher);
    public static void assertThat(String, Object, org.hamcrest.Matcher);
}
org/junit/After.class
package org.junit;
public abstract interface After extends annotation.Annotation {
}
org/junit/rules/Stopwatch$Clock.class
package org.junit.rules;
synchronized class Stopwatch$Clock {
    void Stopwatch$Clock();
    public long nanoTime();
}
org/junit/rules/DisableOnDebug.class
package org.junit.rules;
public synchronized class DisableOnDebug implements TestRule {
    private final TestRule rule;
    private final boolean debugging;
    public void DisableOnDebug(TestRule);
    void DisableOnDebug(TestRule, java.util.List);
    public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
    private static boolean isDebugging(java.util.List);
    public boolean isDebugging();
}
org/junit/rules/ExternalResource.class
package org.junit.rules;
public abstract synchronized class ExternalResource implements TestRule {
    public void ExternalResource();
    public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
    private org.junit.runners.model.Statement statement(org.junit.runners.model.Statement);
    protected void before() throws Throwable;
    protected void after();
}
org/junit/rules/TestWatcher$1.class
package org.junit.rules;
synchronized class TestWatcher$1 extends org.junit.runners.model.Statement {
    void TestWatcher$1(TestWatcher, org.junit.runner.Description, org.junit.runners.model.Statement) throws Exception;
    public void evaluate() throws Throwable;
}
org/junit/rules/TemporaryFolder.class
package org.junit.rules;
public synchronized class TemporaryFolder extends ExternalResource {
    private final java.io.File parentFolder;
    private java.io.File folder;
    public void TemporaryFolder();
    public void TemporaryFolder(java.io.File);
    protected void before() throws Throwable;
    protected void after();
    public void create() throws java.io.IOException;
    public java.io.File newFile(String) throws java.io.IOException;
    public java.io.File newFile() throws java.io.IOException;
    public java.io.File newFolder(String) throws java.io.IOException;
    public transient java.io.File newFolder(String[]) throws java.io.IOException;
    private void validateFolderName(String) throws java.io.IOException;
    private boolean isLastElementInArray(int, String[]);
    public java.io.File newFolder() throws java.io.IOException;
    private java.io.File createTemporaryFolderIn(java.io.File) throws java.io.IOException;
    public java.io.File getRoot();
    public void delete();
    private void recursiveDelete(java.io.File);
}
org/junit/rules/Timeout$Builder.class
package org.junit.rules;
public synchronized class Timeout$Builder {
    private boolean lookForStuckThread;
    private long timeout;
    private java.util.concurrent.TimeUnit timeUnit;
    protected void Timeout$Builder();
    public Timeout$Builder withTimeout(long, java.util.concurrent.TimeUnit);
    protected long getTimeout();
    protected java.util.concurrent.TimeUnit getTimeUnit();
    public Timeout$Builder withLookingForStuckThread(boolean);
    protected boolean getLookingForStuckThread();
    public Timeout build();
}
org/junit/rules/RunRules.class
package org.junit.rules;
public synchronized class RunRules extends org.junit.runners.model.Statement {
    private final org.junit.runners.model.Statement statement;
    public void RunRules(org.junit.runners.model.Statement, Iterable, org.junit.runner.Description);
    public void evaluate() throws Throwable;
    private static org.junit.runners.model.Statement applyAll(org.junit.runners.model.Statement, Iterable, org.junit.runner.Description);
}
org/junit/rules/TestWatchman$1.class
package org.junit.rules;
synchronized class TestWatchman$1 extends org.junit.runners.model.Statement {
    void TestWatchman$1(TestWatchman, org.junit.runners.model.FrameworkMethod, org.junit.runners.model.Statement) throws Throwable;
    public void evaluate() throws Throwable;
}
org/junit/rules/Verifier$1.class
package org.junit.rules;
synchronized class Verifier$1 extends org.junit.runners.model.Statement {
    void Verifier$1(Verifier, org.junit.runners.model.Statement) throws Throwable;
    public void evaluate() throws Throwable;
}
org/junit/rules/ExpectedException.class
package org.junit.rules;
public synchronized class ExpectedException implements TestRule {
    private final ExpectedExceptionMatcherBuilder matcherBuilder;
    private String missingExceptionMessage;
    public static ExpectedException none();
    private void ExpectedException();
    public ExpectedException handleAssertionErrors();
    public ExpectedException handleAssumptionViolatedExceptions();
    public ExpectedException reportMissingExceptionWithMessage(String);
    public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
    public void expect(org.hamcrest.Matcher);
    public void expect(Class);
    public void expectMessage(String);
    public void expectMessage(org.hamcrest.Matcher);
    public void expectCause(org.hamcrest.Matcher);
    private void handleException(Throwable) throws Throwable;
    private boolean isAnyExceptionExpected();
    private void failDueToMissingException() throws AssertionError;
    private String missingExceptionMessage();
}
org/junit/rules/ExpectedException$ExpectedExceptionStatement.class
package org.junit.rules;
synchronized class ExpectedException$ExpectedExceptionStatement extends org.junit.runners.model.Statement {
    private final org.junit.runners.model.Statement next;
    public void ExpectedException$ExpectedExceptionStatement(ExpectedException, org.junit.runners.model.Statement);
    public void evaluate() throws Throwable;
}
org/junit/rules/RuleChain.class
package org.junit.rules;
public synchronized class RuleChain implements TestRule {
    private static final RuleChain EMPTY_CHAIN;
    private java.util.List rulesStartingWithInnerMost;
    public static RuleChain emptyRuleChain();
    public static RuleChain outerRule(TestRule);
    private void RuleChain(java.util.List);
    public RuleChain around(TestRule);
    public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
    static void ();
}
org/junit/rules/ErrorCollector$1.class
package org.junit.rules;
synchronized class ErrorCollector$1 implements java.util.concurrent.Callable {
    void ErrorCollector$1(ErrorCollector, String, Object, org.hamcrest.Matcher);
    public Object call() throws Exception;
}
org/junit/rules/TestRule.class
package org.junit.rules;
public abstract interface TestRule {
    public abstract org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
}
org/junit/rules/Verifier.class
package org.junit.rules;
public abstract synchronized class Verifier implements TestRule {
    public void Verifier();
    public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
    protected void verify() throws Throwable;
}
org/junit/rules/Stopwatch.class
package org.junit.rules;
public abstract synchronized class Stopwatch implements TestRule {
    private final Stopwatch$Clock clock;
    private volatile long startNanos;
    private volatile long endNanos;
    public void Stopwatch();
    void Stopwatch(Stopwatch$Clock);
    public long runtime(java.util.concurrent.TimeUnit);
    protected void succeeded(long, org.junit.runner.Description);
    protected void failed(long, Throwable, org.junit.runner.Description);
    protected void skipped(long, org.junit.AssumptionViolatedException, org.junit.runner.Description);
    protected void finished(long, org.junit.runner.Description);
    private long getNanos();
    private void starting();
    private void stopping();
    public final org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
}
org/junit/rules/Stopwatch$1.class
package org.junit.rules;
synchronized class Stopwatch$1 {
}
org/junit/rules/Timeout.class
package org.junit.rules;
public synchronized class Timeout implements TestRule {
    private final long timeout;
    private final java.util.concurrent.TimeUnit timeUnit;
    private final boolean lookForStuckThread;
    public static Timeout$Builder builder();
    public void Timeout(int);
    public void Timeout(long, java.util.concurrent.TimeUnit);
    protected void Timeout(Timeout$Builder);
    public static Timeout millis(long);
    public static Timeout seconds(long);
    protected final long getTimeout(java.util.concurrent.TimeUnit);
    protected final boolean getLookingForStuckThread();
    protected org.junit.runners.model.Statement createFailOnTimeoutStatement(org.junit.runners.model.Statement) throws Exception;
    public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
}
org/junit/rules/ExpectedExceptionMatcherBuilder.class
package org.junit.rules;
synchronized class ExpectedExceptionMatcherBuilder {
    private final java.util.List matchers;
    void ExpectedExceptionMatcherBuilder();
    void add(org.hamcrest.Matcher);
    boolean expectsThrowable();
    org.hamcrest.Matcher build();
    private org.hamcrest.Matcher allOfTheMatchers();
    private java.util.List castedMatchers();
    private org.hamcrest.Matcher cast(org.hamcrest.Matcher);
}
org/junit/rules/MethodRule.class
package org.junit.rules;
public abstract interface MethodRule {
    public abstract org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runners.model.FrameworkMethod, Object);
}
org/junit/rules/Timeout$1.class
package org.junit.rules;
synchronized class Timeout$1 extends org.junit.runners.model.Statement {
    void Timeout$1(Timeout, Exception);
    public void evaluate() throws Throwable;
}
org/junit/rules/ExternalResource$1.class
package org.junit.rules;
synchronized class ExternalResource$1 extends org.junit.runners.model.Statement {
    void ExternalResource$1(ExternalResource, org.junit.runners.model.Statement) throws Throwable;
    public void evaluate() throws Throwable;
}
org/junit/rules/TestWatchman.class
package org.junit.rules;
public synchronized class TestWatchman implements MethodRule {
    public void TestWatchman();
    public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runners.model.FrameworkMethod, Object);
    public void succeeded(org.junit.runners.model.FrameworkMethod);
    public void failed(Throwable, org.junit.runners.model.FrameworkMethod);
    public void starting(org.junit.runners.model.FrameworkMethod);
    public void finished(org.junit.runners.model.FrameworkMethod);
}
org/junit/rules/ErrorCollector.class
package org.junit.rules;
public synchronized class ErrorCollector extends Verifier {
    private java.util.List errors;
    public void ErrorCollector();
    protected void verify() throws Throwable;
    public void addError(Throwable);
    public void checkThat(Object, org.hamcrest.Matcher);
    public void checkThat(String, Object, org.hamcrest.Matcher);
    public Object checkSucceeds(java.util.concurrent.Callable);
}
org/junit/rules/TestWatcher.class
package org.junit.rules;
public abstract synchronized class TestWatcher implements TestRule {
    public void TestWatcher();
    public org.junit.runners.model.Statement apply(org.junit.runners.model.Statement, org.junit.runner.Description);
    private void succeededQuietly(org.junit.runner.Description, java.util.List);
    private void failedQuietly(Throwable, org.junit.runner.Description, java.util.List);
    private void skippedQuietly(org.junit.internal.AssumptionViolatedException, org.junit.runner.Description, java.util.List);
    private void startingQuietly(org.junit.runner.Description, java.util.List);
    private void finishedQuietly(org.junit.runner.Description, java.util.List);
    protected void succeeded(org.junit.runner.Description);
    protected void failed(Throwable, org.junit.runner.Description);
    protected void skipped(org.junit.AssumptionViolatedException, org.junit.runner.Description);
    protected void skipped(org.junit.internal.AssumptionViolatedException, org.junit.runner.Description);
    protected void starting(org.junit.runner.Description);
    protected void finished(org.junit.runner.Description);
}
org/junit/rules/Stopwatch$InternalWatcher.class
package org.junit.rules;
synchronized class Stopwatch$InternalWatcher extends TestWatcher {
    private void Stopwatch$InternalWatcher(Stopwatch);
    protected void starting(org.junit.runner.Description);
    protected void finished(org.junit.runner.Description);
    protected void succeeded(org.junit.runner.Description);
    protected void failed(Throwable, org.junit.runner.Description);
    protected void skipped(org.junit.AssumptionViolatedException, org.junit.runner.Description);
}
org/junit/rules/TestName.class
package org.junit.rules;
public synchronized class TestName extends TestWatcher {
    private String name;
    public void TestName();
    protected void starting(org.junit.runner.Description);
    public String getMethodName();
}
org/junit/AssumptionViolatedException.class
package org.junit;
public synchronized class AssumptionViolatedException extends internal.AssumptionViolatedException {
    private static final long serialVersionUID = 1;
    public void AssumptionViolatedException(Object, org.hamcrest.Matcher);
    public void AssumptionViolatedException(String, Object, org.hamcrest.Matcher);
    public void AssumptionViolatedException(String);
    public void AssumptionViolatedException(String, Throwable);
}
org/junit/ComparisonFailure$ComparisonCompactor$DiffExtractor.class
package org.junit;
synchronized class ComparisonFailure$ComparisonCompactor$DiffExtractor {
    private final String sharedPrefix;
    private final String sharedSuffix;
    private void ComparisonFailure$ComparisonCompactor$DiffExtractor(ComparisonFailure$ComparisonCompactor);
    public String expectedDiff();
    public String actualDiff();
    public String compactPrefix();
    public String compactSuffix();
    private String extractDiff(String);
}
org/junit/Assume.class
package org.junit;
public synchronized class Assume {
    public void Assume();
    public static void assumeTrue(boolean);
    public static void assumeFalse(boolean);
    public static void assumeTrue(String, boolean);
    public static void assumeFalse(String, boolean);
    public static transient void assumeNotNull(Object[]);
    public static void assumeThat(Object, org.hamcrest.Matcher);
    public static void assumeThat(String, Object, org.hamcrest.Matcher);
    public static void assumeNoException(Throwable);
    public static void assumeNoException(String, Throwable);
}
org/junit/runners/AllTests.class
package org.junit.runners;
public synchronized class AllTests extends org.junit.internal.runners.SuiteMethod {
    public void AllTests(Class) throws Throwable;
}
org/junit/runners/Suite$SuiteClasses.class
package org.junit.runners;
public abstract interface Suite$SuiteClasses extends annotation.Annotation {
    public abstract Class[] value();
}
org/junit/runners/JUnit4.class
package org.junit.runners;
public final synchronized class JUnit4 extends BlockJUnit4ClassRunner {
    public void JUnit4(Class) throws model.InitializationError;
}
org/junit/runners/ParentRunner$1.class
package org.junit.runners;
synchronized class ParentRunner$1 implements model.RunnerScheduler {
    void ParentRunner$1(ParentRunner);
    public void schedule(Runnable);
    public void finished();
}
org/junit/runners/BlockJUnit4ClassRunner.class
package org.junit.runners;
public synchronized class BlockJUnit4ClassRunner extends ParentRunner {
    private final java.util.concurrent.ConcurrentHashMap methodDescriptions;
    public void BlockJUnit4ClassRunner(Class) throws model.InitializationError;
    protected void runChild(model.FrameworkMethod, org.junit.runner.notification.RunNotifier);
    protected boolean isIgnored(model.FrameworkMethod);
    protected org.junit.runner.Description describeChild(model.FrameworkMethod);
    protected java.util.List getChildren();
    protected java.util.List computeTestMethods();
    protected void collectInitializationErrors(java.util.List);
    protected void validateNoNonStaticInnerClass(java.util.List);
    protected void validateConstructor(java.util.List);
    protected void validateOnlyOneConstructor(java.util.List);
    protected void validateZeroArgConstructor(java.util.List);
    private boolean hasOneConstructor();
    protected void validateInstanceMethods(java.util.List);
    protected void validateFields(java.util.List);
    private void validateMethods(java.util.List);
    protected void validateTestMethods(java.util.List);
    protected Object createTest() throws Exception;
    protected String testName(model.FrameworkMethod);
    protected model.Statement methodBlock(model.FrameworkMethod);
    protected model.Statement methodInvoker(model.FrameworkMethod, Object);
    protected model.Statement possiblyExpectingExceptions(model.FrameworkMethod, Object, model.Statement);
    protected model.Statement withPotentialTimeout(model.FrameworkMethod, Object, model.Statement);
    protected model.Statement withBefores(model.FrameworkMethod, Object, model.Statement);
    protected model.Statement withAfters(model.FrameworkMethod, Object, model.Statement);
    private model.Statement withRules(model.FrameworkMethod, Object, model.Statement);
    private model.Statement withMethodRules(model.FrameworkMethod, java.util.List, Object, model.Statement);
    private java.util.List getMethodRules(Object);
    protected java.util.List rules(Object);
    private model.Statement withTestRules(model.FrameworkMethod, java.util.List, model.Statement);
    protected java.util.List getTestRules(Object);
    private Class getExpectedException(org.junit.Test);
    private boolean expectsException(org.junit.Test);
    private long getTimeout(org.junit.Test);
}
org/junit/runners/Parameterized$Parameters.class
package org.junit.runners;
public abstract interface Parameterized$Parameters extends annotation.Annotation {
    public abstract String name();
}
org/junit/runners/MethodSorters.class
package org.junit.runners;
public final synchronized enum MethodSorters {
    public static final MethodSorters NAME_ASCENDING;
    public static final MethodSorters JVM;
    public static final MethodSorters DEFAULT;
    private final java.util.Comparator comparator;
    public static final MethodSorters[] values();
    public static MethodSorters valueOf(String);
    private void MethodSorters(String, int, java.util.Comparator);
    public java.util.Comparator getComparator();
    static void ();
}
org/junit/runners/ParentRunner$2.class
package org.junit.runners;
synchronized class ParentRunner$2 extends model.Statement {
    void ParentRunner$2(ParentRunner, org.junit.runner.notification.RunNotifier);
    public void evaluate();
}
org/junit/runners/ParentRunner$3.class
package org.junit.runners;
synchronized class ParentRunner$3 implements Runnable {
    void ParentRunner$3(ParentRunner, Object, org.junit.runner.notification.RunNotifier);
    public void run();
}
org/junit/runners/Parameterized$UseParametersRunnerFactory.class
package org.junit.runners;
public abstract interface Parameterized$UseParametersRunnerFactory extends annotation.Annotation {
    public abstract Class value();
}
org/junit/runners/ParentRunner$4.class
package org.junit.runners;
synchronized class ParentRunner$4 implements java.util.Comparator {
    void ParentRunner$4(ParentRunner, org.junit.runner.manipulation.Sorter);
    public int compare(Object, Object);
}
org/junit/runners/ParentRunner.class
package org.junit.runners;
public abstract synchronized class ParentRunner extends org.junit.runner.Runner implements org.junit.runner.manipulation.Filterable, org.junit.runner.manipulation.Sortable {
    private static final java.util.List VALIDATORS;
    private final Object childrenLock;
    private final model.TestClass testClass;
    private volatile java.util.Collection filteredChildren;
    private volatile model.RunnerScheduler scheduler;
    protected void ParentRunner(Class) throws model.InitializationError;
    protected model.TestClass createTestClass(Class);
    protected abstract java.util.List getChildren();
    protected abstract org.junit.runner.Description describeChild(Object);
    protected abstract void runChild(Object, org.junit.runner.notification.RunNotifier);
    protected void collectInitializationErrors(java.util.List);
    private void applyValidators(java.util.List);
    protected void validatePublicVoidNoArgMethods(Class, boolean, java.util.List);
    private void validateClassRules(java.util.List);
    protected model.Statement classBlock(org.junit.runner.notification.RunNotifier);
    private boolean areAllChildrenIgnored();
    protected model.Statement withBeforeClasses(model.Statement);
    protected model.Statement withAfterClasses(model.Statement);
    private model.Statement withClassRules(model.Statement);
    protected java.util.List classRules();
    protected model.Statement childrenInvoker(org.junit.runner.notification.RunNotifier);
    protected boolean isIgnored(Object);
    private void runChildren(org.junit.runner.notification.RunNotifier);
    protected String getName();
    public final model.TestClass getTestClass();
    protected final void runLeaf(model.Statement, org.junit.runner.Description, org.junit.runner.notification.RunNotifier);
    protected annotation.Annotation[] getRunnerAnnotations();
    public org.junit.runner.Description getDescription();
    public void run(org.junit.runner.notification.RunNotifier);
    public void filter(org.junit.runner.manipulation.Filter) throws org.junit.runner.manipulation.NoTestsRemainException;
    public void sort(org.junit.runner.manipulation.Sorter);
    private void validate() throws model.InitializationError;
    private java.util.Collection getFilteredChildren();
    private boolean shouldRun(org.junit.runner.manipulation.Filter, Object);
    private java.util.Comparator comparator(org.junit.runner.manipulation.Sorter);
    public void setScheduler(model.RunnerScheduler);
    static void ();
}
org/junit/runners/BlockJUnit4ClassRunner$1.class
package org.junit.runners;
synchronized class BlockJUnit4ClassRunner$1 extends org.junit.internal.runners.model.ReflectiveCallable {
    void BlockJUnit4ClassRunner$1(BlockJUnit4ClassRunner) throws Exception;
    protected Object runReflectiveCall() throws Throwable;
}
org/junit/runners/Parameterized$Parameter.class
package org.junit.runners;
public abstract interface Parameterized$Parameter extends annotation.Annotation {
    public abstract int value();
}
org/junit/runners/parameterized/ParametersRunnerFactory.class
package org.junit.runners.parameterized;
public abstract interface ParametersRunnerFactory {
    public abstract org.junit.runner.Runner createRunnerForTestWithParameters(TestWithParameters) throws org.junit.runners.model.InitializationError;
}
org/junit/runners/parameterized/TestWithParameters.class
package org.junit.runners.parameterized;
public synchronized class TestWithParameters {
    private final String name;
    private final org.junit.runners.model.TestClass testClass;
    private final java.util.List parameters;
    public void TestWithParameters(String, org.junit.runners.model.TestClass, java.util.List);
    public String getName();
    public org.junit.runners.model.TestClass getTestClass();
    public java.util.List getParameters();
    public int hashCode();
    public boolean equals(Object);
    public String toString();
    private static void notNull(Object, String);
}
org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParameters.class
package org.junit.runners.parameterized;
public synchronized class BlockJUnit4ClassRunnerWithParameters extends org.junit.runners.BlockJUnit4ClassRunner {
    private final Object[] parameters;
    private final String name;
    public void BlockJUnit4ClassRunnerWithParameters(TestWithParameters) throws org.junit.runners.model.InitializationError;
    public Object createTest() throws Exception;
    private Object createTestUsingConstructorInjection() throws Exception;
    private Object createTestUsingFieldInjection() throws Exception;
    protected String getName();
    protected String testName(org.junit.runners.model.FrameworkMethod);
    protected void validateConstructor(java.util.List);
    protected void validateFields(java.util.List);
    protected org.junit.runners.model.Statement classBlock(org.junit.runner.notification.RunNotifier);
    protected annotation.Annotation[] getRunnerAnnotations();
    private java.util.List getAnnotatedFieldsByParameter();
    private boolean fieldsAreAnnotated();
}
org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParametersFactory.class
package org.junit.runners.parameterized;
public synchronized class BlockJUnit4ClassRunnerWithParametersFactory implements ParametersRunnerFactory {
    public void BlockJUnit4ClassRunnerWithParametersFactory();
    public org.junit.runner.Runner createRunnerForTestWithParameters(TestWithParameters) throws org.junit.runners.model.InitializationError;
}
org/junit/runners/Suite.class
package org.junit.runners;
public synchronized class Suite extends ParentRunner {
    private final java.util.List runners;
    public static org.junit.runner.Runner emptySuite();
    private static Class[] getAnnotatedClasses(Class) throws model.InitializationError;
    public void Suite(Class, model.RunnerBuilder) throws model.InitializationError;
    public void Suite(model.RunnerBuilder, Class[]) throws model.InitializationError;
    protected void Suite(Class, Class[]) throws model.InitializationError;
    protected void Suite(model.RunnerBuilder, Class, Class[]) throws model.InitializationError;
    protected void Suite(Class, java.util.List) throws model.InitializationError;
    protected java.util.List getChildren();
    protected org.junit.runner.Description describeChild(org.junit.runner.Runner);
    protected void runChild(org.junit.runner.Runner, org.junit.runner.notification.RunNotifier);
}
org/junit/runners/model/MultipleFailureException.class
package org.junit.runners.model;
public synchronized class MultipleFailureException extends Exception {
    private static final long serialVersionUID = 1;
    private final java.util.List fErrors;
    public void MultipleFailureException(java.util.List);
    public java.util.List getFailures();
    public String getMessage();
    public static void assertEmpty(java.util.List) throws Exception;
}
org/junit/runners/model/RunnerScheduler.class
package org.junit.runners.model;
public abstract interface RunnerScheduler {
    public abstract void schedule(Runnable);
    public abstract void finished();
}
org/junit/runners/model/NoGenericTypeParametersValidator.class
package org.junit.runners.model;
synchronized class NoGenericTypeParametersValidator {
    private final reflect.Method method;
    void NoGenericTypeParametersValidator(reflect.Method);
    void validate(java.util.List);
    private void validateNoTypeParameterOnType(reflect.Type, java.util.List);
    private void validateNoTypeParameterOnParameterizedType(reflect.ParameterizedType, java.util.List);
    private void validateNoTypeParameterOnWildcardType(reflect.WildcardType, java.util.List);
    private void validateNoTypeParameterOnGenericArrayType(reflect.GenericArrayType, java.util.List);
}
org/junit/runners/model/TestClass$1.class
package org.junit.runners.model;
synchronized class TestClass$1 {
}
org/junit/runners/model/RunnerBuilder.class
package org.junit.runners.model;
public abstract synchronized class RunnerBuilder {
    private final java.util.Set parents;
    public void RunnerBuilder();
    public abstract org.junit.runner.Runner runnerForClass(Class) throws Throwable;
    public org.junit.runner.Runner safeRunnerForClass(Class);
    Class addParent(Class) throws InitializationError;
    void removeParent(Class);
    public java.util.List runners(Class, Class[]) throws InitializationError;
    public java.util.List runners(Class, java.util.List) throws InitializationError;
    private java.util.List runners(Class[]);
}
org/junit/runners/model/Annotatable.class
package org.junit.runners.model;
public abstract interface Annotatable {
    public abstract annotation.Annotation[] getAnnotations();
    public abstract annotation.Annotation getAnnotation(Class);
}
org/junit/runners/model/FrameworkField.class
package org.junit.runners.model;
public synchronized class FrameworkField extends FrameworkMember {
    private final reflect.Field field;
    void FrameworkField(reflect.Field);
    public String getName();
    public annotation.Annotation[] getAnnotations();
    public annotation.Annotation getAnnotation(Class);
    public boolean isShadowedBy(FrameworkField);
    protected int getModifiers();
    public reflect.Field getField();
    public Class getType();
    public Class getDeclaringClass();
    public Object get(Object) throws IllegalArgumentException, IllegalAccessException;
    public String toString();
}
org/junit/runners/model/Statement.class
package org.junit.runners.model;
public abstract synchronized class Statement {
    public void Statement();
    public abstract void evaluate() throws Throwable;
}
org/junit/runners/model/TestTimedOutException.class
package org.junit.runners.model;
public synchronized class TestTimedOutException extends Exception {
    private static final long serialVersionUID = 31935685163547539;
    private final java.util.concurrent.TimeUnit timeUnit;
    private final long timeout;
    public void TestTimedOutException(long, java.util.concurrent.TimeUnit);
    public long getTimeout();
    public java.util.concurrent.TimeUnit getTimeUnit();
}
org/junit/runners/model/FrameworkMember.class
package org.junit.runners.model;
public abstract synchronized class FrameworkMember implements Annotatable {
    public void FrameworkMember();
    abstract boolean isShadowedBy(FrameworkMember);
    boolean isShadowedBy(java.util.List);
    protected abstract int getModifiers();
    public boolean isStatic();
    public boolean isPublic();
    public abstract String getName();
    public abstract Class getType();
    public abstract Class getDeclaringClass();
}
org/junit/runners/model/TestClass.class
package org.junit.runners.model;
public synchronized class TestClass implements Annotatable {
    private static final TestClass$FieldComparator FIELD_COMPARATOR;
    private static final TestClass$MethodComparator METHOD_COMPARATOR;
    private final Class clazz;
    private final java.util.Map methodsForAnnotations;
    private final java.util.Map fieldsForAnnotations;
    public void TestClass(Class);
    protected void scanAnnotatedMembers(java.util.Map, java.util.Map);
    private static reflect.Field[] getSortedDeclaredFields(Class);
    protected static void addToAnnotationLists(FrameworkMember, java.util.Map);
    private static java.util.Map makeDeeplyUnmodifiable(java.util.Map);
    public java.util.List getAnnotatedMethods();
    public java.util.List getAnnotatedMethods(Class);
    public java.util.List getAnnotatedFields();
    public java.util.List getAnnotatedFields(Class);
    private java.util.List collectValues(java.util.Map);
    private static java.util.List getAnnotatedMembers(java.util.Map, Class, boolean);
    private static boolean runsTopToBottom(Class);
    private static java.util.List getSuperClasses(Class);
    public Class getJavaClass();
    public String getName();
    public reflect.Constructor getOnlyConstructor();
    public annotation.Annotation[] getAnnotations();
    public annotation.Annotation getAnnotation(Class);
    public java.util.List getAnnotatedFieldValues(Object, Class, Class);
    public java.util.List getAnnotatedMethodValues(Object, Class, Class);
    public boolean isPublic();
    public boolean isANonStaticInnerClass();
    public int hashCode();
    public boolean equals(Object);
    static void ();
}
org/junit/runners/model/TestClass$FieldComparator.class
package org.junit.runners.model;
synchronized class TestClass$FieldComparator implements java.util.Comparator {
    private void TestClass$FieldComparator();
    public int compare(reflect.Field, reflect.Field);
}
org/junit/runners/model/FrameworkMethod.class
package org.junit.runners.model;
public synchronized class FrameworkMethod extends FrameworkMember {
    private final reflect.Method method;
    public void FrameworkMethod(reflect.Method);
    public reflect.Method getMethod();
    public transient Object invokeExplosively(Object, Object[]) throws Throwable;
    public String getName();
    public void validatePublicVoidNoArg(boolean, java.util.List);
    public void validatePublicVoid(boolean, java.util.List);
    protected int getModifiers();
    public Class getReturnType();
    public Class getType();
    public Class getDeclaringClass();
    public void validateNoTypeParametersOnArgs(java.util.List);
    public boolean isShadowedBy(FrameworkMethod);
    public boolean equals(Object);
    public int hashCode();
    public boolean producesType(reflect.Type);
    private Class[] getParameterTypes();
    public annotation.Annotation[] getAnnotations();
    public annotation.Annotation getAnnotation(Class);
    public String toString();
}
org/junit/runners/model/TestClass$MethodComparator.class
package org.junit.runners.model;
synchronized class TestClass$MethodComparator implements java.util.Comparator {
    private void TestClass$MethodComparator();
    public int compare(FrameworkMethod, FrameworkMethod);
}
org/junit/runners/model/InitializationError.class
package org.junit.runners.model;
public synchronized class InitializationError extends Exception {
    private static final long serialVersionUID = 1;
    private final java.util.List fErrors;
    public void InitializationError(java.util.List);
    public void InitializationError(Throwable);
    public void InitializationError(String);
    public java.util.List getCauses();
}
org/junit/runners/model/FrameworkMethod$1.class
package org.junit.runners.model;
synchronized class FrameworkMethod$1 extends org.junit.internal.runners.model.ReflectiveCallable {
    void FrameworkMethod$1(FrameworkMethod, Object, Object[]) throws reflect.InvocationTargetException, IllegalAccessException;
    protected Object runReflectiveCall() throws Throwable;
}
org/junit/runners/Parameterized.class
package org.junit.runners;
public synchronized class Parameterized extends Suite {
    private static final parameterized.ParametersRunnerFactory DEFAULT_FACTORY;
    private static final java.util.List NO_RUNNERS;
    private final java.util.List runners;
    public void Parameterized(Class) throws Throwable;
    private parameterized.ParametersRunnerFactory getParametersRunnerFactory(Class) throws InstantiationException, IllegalAccessException;
    protected java.util.List getChildren();
    private parameterized.TestWithParameters createTestWithNotNormalizedParameters(String, int, Object);
    private Iterable allParameters() throws Throwable;
    private model.FrameworkMethod getParametersMethod() throws Exception;
    private java.util.List createRunnersForParameters(Iterable, String, parameterized.ParametersRunnerFactory) throws model.InitializationError, Exception;
    private java.util.List createTestsForParameters(Iterable, String) throws Exception;
    private Exception parametersMethodReturnedWrongType() throws Exception;
    private static parameterized.TestWithParameters createTestWithParameters(model.TestClass, String, int, Object[]);
    static void ();
}
org/junit/ComparisonFailure.class
package org.junit;
public synchronized class ComparisonFailure extends AssertionError {
    private static final int MAX_CONTEXT_LENGTH = 20;
    private static final long serialVersionUID = 1;
    private String fExpected;
    private String fActual;
    public void ComparisonFailure(String, String, String);
    public String getMessage();
    public String getActual();
    public String getExpected();
}
org/junit/matchers/JUnitMatchers.class
package org.junit.matchers;
public synchronized class JUnitMatchers {
    public void JUnitMatchers();
    public static org.hamcrest.Matcher hasItem(Object);
    public static org.hamcrest.Matcher hasItem(org.hamcrest.Matcher);
    public static transient org.hamcrest.Matcher hasItems(Object[]);
    public static transient org.hamcrest.Matcher hasItems(org.hamcrest.Matcher[]);
    public static org.hamcrest.Matcher everyItem(org.hamcrest.Matcher);
    public static org.hamcrest.Matcher containsString(String);
    public static org.hamcrest.core.CombinableMatcher$CombinableBothMatcher both(org.hamcrest.Matcher);
    public static org.hamcrest.core.CombinableMatcher$CombinableEitherMatcher either(org.hamcrest.Matcher);
    public static org.hamcrest.Matcher isThrowable(org.hamcrest.Matcher);
    public static org.hamcrest.Matcher isException(org.hamcrest.Matcher);
}
org/junit/Test$None.class
package org.junit;
public synchronized class Test$None extends Throwable {
    private static final long serialVersionUID = 1;
    private void Test$None();
}
org/junit/runner/FilterFactory.class
package org.junit.runner;
public abstract interface FilterFactory {
    public abstract manipulation.Filter createFilter(FilterFactoryParams) throws FilterFactory$FilterNotCreatedException;
}
org/junit/runner/Result.class
package org.junit.runner;
public synchronized class Result implements java.io.Serializable {
    private static final long serialVersionUID = 1;
    private static final java.io.ObjectStreamField[] serialPersistentFields;
    private final java.util.concurrent.atomic.AtomicInteger count;
    private final java.util.concurrent.atomic.AtomicInteger ignoreCount;
    private final java.util.concurrent.CopyOnWriteArrayList failures;
    private final java.util.concurrent.atomic.AtomicLong runTime;
    private final java.util.concurrent.atomic.AtomicLong startTime;
    private Result$SerializedForm serializedForm;
    public void Result();
    private void Result(Result$SerializedForm);
    public int getRunCount();
    public int getFailureCount();
    public long getRunTime();
    public java.util.List getFailures();
    public int getIgnoreCount();
    public boolean wasSuccessful();
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    private void readObject(java.io.ObjectInputStream) throws ClassNotFoundException, java.io.IOException;
    private Object readResolve();
    public notification.RunListener createListener();
    static void ();
}
org/junit/runner/JUnitCommandLineParseResult$CommandLineParserError.class
package org.junit.runner;
public synchronized class JUnitCommandLineParseResult$CommandLineParserError extends Exception {
    private static final long serialVersionUID = 1;
    public void JUnitCommandLineParseResult$CommandLineParserError(String);
}
org/junit/runner/Result$Listener.class
package org.junit.runner;
synchronized class Result$Listener extends notification.RunListener {
    private void Result$Listener(Result);
    public void testRunStarted(Description) throws Exception;
    public void testRunFinished(Result) throws Exception;
    public void testFinished(Description) throws Exception;
    public void testFailure(notification.Failure) throws Exception;
    public void testIgnored(Description) throws Exception;
    public void testAssumptionFailure(notification.Failure);
}
org/junit/runner/JUnitCommandLineParseResult.class
package org.junit.runner;
synchronized class JUnitCommandLineParseResult {
    private final java.util.List filterSpecs;
    private final java.util.List classes;
    private final java.util.List parserErrors;
    void JUnitCommandLineParseResult();
    public java.util.List getFilterSpecs();
    public java.util.List getClasses();
    public static JUnitCommandLineParseResult parse(String[]);
    private void parseArgs(String[]);
    transient String[] parseOptions(String[]);
    private String[] copyArray(String[], int, int);
    void parseParameters(String[]);
    private Request errorReport(Throwable);
    public Request createRequest(Computer);
    private Request applyFilterSpecs(Request);
}
org/junit/runner/Describable.class
package org.junit.runner;
public abstract interface Describable {
    public abstract Description getDescription();
}
org/junit/runner/FilterFactories.class
package org.junit.runner;
synchronized class FilterFactories {
    void FilterFactories();
    public static manipulation.Filter createFilterFromFilterSpec(Request, String) throws FilterFactory$FilterNotCreatedException;
    public static manipulation.Filter createFilter(String, FilterFactoryParams) throws FilterFactory$FilterNotCreatedException;
    public static manipulation.Filter createFilter(Class, FilterFactoryParams) throws FilterFactory$FilterNotCreatedException;
    static FilterFactory createFilterFactory(String) throws FilterFactory$FilterNotCreatedException;
    static FilterFactory createFilterFactory(Class) throws FilterFactory$FilterNotCreatedException;
}
org/junit/runner/Result$SerializedForm.class
package org.junit.runner;
synchronized class Result$SerializedForm implements java.io.Serializable {
    private static final long serialVersionUID = 1;
    private final java.util.concurrent.atomic.AtomicInteger fCount;
    private final java.util.concurrent.atomic.AtomicInteger fIgnoreCount;
    private final java.util.List fFailures;
    private final long fRunTime;
    private final long fStartTime;
    public void Result$SerializedForm(Result);
    private void Result$SerializedForm(java.io.ObjectInputStream$GetField) throws java.io.IOException;
    public void serialize(java.io.ObjectOutputStream) throws java.io.IOException;
    public static Result$SerializedForm deserialize(java.io.ObjectInputStream) throws ClassNotFoundException, java.io.IOException;
}
org/junit/runner/Runner.class
package org.junit.runner;
public abstract synchronized class Runner implements Describable {
    public void Runner();
    public abstract Description getDescription();
    public abstract void run(notification.RunNotifier);
    public int testCount();
}
org/junit/runner/RunWith.class
package org.junit.runner;
public abstract interface RunWith extends annotation.Annotation {
    public abstract Class value();
}
org/junit/runner/manipulation/NoTestsRemainException.class
package org.junit.runner.manipulation;
public synchronized class NoTestsRemainException extends Exception {
    private static final long serialVersionUID = 1;
    public void NoTestsRemainException();
}
org/junit/runner/manipulation/Sortable.class
package org.junit.runner.manipulation;
public abstract interface Sortable {
    public abstract void sort(Sorter);
}
org/junit/runner/manipulation/Filter.class
package org.junit.runner.manipulation;
public abstract synchronized class Filter {
    public static final Filter ALL;
    public void Filter();
    public static Filter matchMethodDescription(org.junit.runner.Description);
    public abstract boolean shouldRun(org.junit.runner.Description);
    public abstract String describe();
    public void apply(Object) throws NoTestsRemainException;
    public Filter intersect(Filter);
    static void ();
}
org/junit/runner/manipulation/Filter$2.class
package org.junit.runner.manipulation;
synchronized class Filter$2 extends Filter {
    void Filter$2(org.junit.runner.Description);
    public boolean shouldRun(org.junit.runner.Description);
    public String describe();
}
org/junit/runner/manipulation/Filter$3.class
package org.junit.runner.manipulation;
synchronized class Filter$3 extends Filter {
    void Filter$3(Filter, Filter, Filter);
    public boolean shouldRun(org.junit.runner.Description);
    public String describe();
}
org/junit/runner/manipulation/Sorter.class
package org.junit.runner.manipulation;
public synchronized class Sorter implements java.util.Comparator {
    public static final Sorter NULL;
    private final java.util.Comparator comparator;
    public void Sorter(java.util.Comparator);
    public void apply(Object);
    public int compare(org.junit.runner.Description, org.junit.runner.Description);
    static void ();
}
org/junit/runner/manipulation/Sorter$1.class
package org.junit.runner.manipulation;
synchronized class Sorter$1 implements java.util.Comparator {
    void Sorter$1();
    public int compare(org.junit.runner.Description, org.junit.runner.Description);
}
org/junit/runner/manipulation/Filterable.class
package org.junit.runner.manipulation;
public abstract interface Filterable {
    public abstract void filter(Filter) throws NoTestsRemainException;
}
org/junit/runner/manipulation/Filter$1.class
package org.junit.runner.manipulation;
synchronized class Filter$1 extends Filter {
    void Filter$1();
    public boolean shouldRun(org.junit.runner.Description);
    public String describe();
    public void apply(Object) throws NoTestsRemainException;
    public Filter intersect(Filter);
}
org/junit/runner/JUnitCore.class
package org.junit.runner;
public synchronized class JUnitCore {
    private final notification.RunNotifier notifier;
    public void JUnitCore();
    public static transient void main(String[]);
    public static transient Result runClasses(Class[]);
    public static transient Result runClasses(Computer, Class[]);
    transient Result runMain(org.junit.internal.JUnitSystem, String[]);
    public String getVersion();
    public transient Result run(Class[]);
    public transient Result run(Computer, Class[]);
    public Result run(Request);
    public Result run(junit.framework.Test);
    public Result run(Runner);
    public void addListener(notification.RunListener);
    public void removeListener(notification.RunListener);
    static Computer defaultComputer();
}
org/junit/runner/FilterFactory$FilterNotCreatedException.class
package org.junit.runner;
public synchronized class FilterFactory$FilterNotCreatedException extends Exception {
    public void FilterFactory$FilterNotCreatedException(Exception);
}
org/junit/runner/Result$1.class
package org.junit.runner;
synchronized class Result$1 {
}
org/junit/runner/Request.class
package org.junit.runner;
public abstract synchronized class Request {
    public void Request();
    public static Request method(Class, String);
    public static Request aClass(Class);
    public static Request classWithoutSuiteMethod(Class);
    public static transient Request classes(Computer, Class[]);
    public static transient Request classes(Class[]);
    public static Request errorReport(Class, Throwable);
    public static Request runner(Runner);
    public abstract Runner getRunner();
    public Request filterWith(manipulation.Filter);
    public Request filterWith(Description);
    public Request sortWith(java.util.Comparator);
}
org/junit/runner/FilterFactoryParams.class
package org.junit.runner;
public final synchronized class FilterFactoryParams {
    private final Description topLevelDescription;
    private final String args;
    public void FilterFactoryParams(Description, String);
    public String getArgs();
    public Description getTopLevelDescription();
}
org/junit/runner/Computer$1.class
package org.junit.runner;
synchronized class Computer$1 extends org.junit.runners.model.RunnerBuilder {
    void Computer$1(Computer, org.junit.runners.model.RunnerBuilder) throws Throwable;
    public Runner runnerForClass(Class) throws Throwable;
}
org/junit/runner/Request$1.class
package org.junit.runner;
synchronized class Request$1 extends Request {
    void Request$1(Runner);
    public Runner getRunner();
}
org/junit/runner/notification/Failure.class
package org.junit.runner.notification;
public synchronized class Failure implements java.io.Serializable {
    private static final long serialVersionUID = 1;
    private final org.junit.runner.Description fDescription;
    private final Throwable fThrownException;
    public void Failure(org.junit.runner.Description, Throwable);
    public String getTestHeader();
    public org.junit.runner.Description getDescription();
    public Throwable getException();
    public String toString();
    public String getTrace();
    public String getMessage();
}
org/junit/runner/notification/RunNotifier.class
package org.junit.runner.notification;
public synchronized class RunNotifier {
    private final java.util.List listeners;
    private volatile boolean pleaseStop;
    public void RunNotifier();
    public void addListener(RunListener);
    public void removeListener(RunListener);
    RunListener wrapIfNotThreadSafe(RunListener);
    public void fireTestRunStarted(org.junit.runner.Description);
    public void fireTestRunFinished(org.junit.runner.Result);
    public void fireTestStarted(org.junit.runner.Description) throws StoppedByUserException;
    public void fireTestFailure(Failure);
    private void fireTestFailures(java.util.List, java.util.List);
    public void fireTestAssumptionFailed(Failure);
    public void fireTestIgnored(org.junit.runner.Description);
    public void fireTestFinished(org.junit.runner.Description);
    public void pleaseStop();
    public void addFirstListener(RunListener);
}
org/junit/runner/notification/RunNotifier$1.class
package org.junit.runner.notification;
synchronized class RunNotifier$1 extends RunNotifier$SafeNotifier {
    void RunNotifier$1(RunNotifier, org.junit.runner.Description) throws Exception;
    protected void notifyListener(RunListener) throws Exception;
}
org/junit/runner/notification/RunNotifier$2.class
package org.junit.runner.notification;
synchronized class RunNotifier$2 extends RunNotifier$SafeNotifier {
    void RunNotifier$2(RunNotifier, org.junit.runner.Result) throws Exception;
    protected void notifyListener(RunListener) throws Exception;
}
org/junit/runner/notification/RunNotifier$3.class
package org.junit.runner.notification;
synchronized class RunNotifier$3 extends RunNotifier$SafeNotifier {
    void RunNotifier$3(RunNotifier, org.junit.runner.Description) throws Exception;
    protected void notifyListener(RunListener) throws Exception;
}
org/junit/runner/notification/RunListener$ThreadSafe.class
package org.junit.runner.notification;
public abstract interface RunListener$ThreadSafe extends annotation.Annotation {
}
org/junit/runner/notification/RunNotifier$4.class
package org.junit.runner.notification;
synchronized class RunNotifier$4 extends RunNotifier$SafeNotifier {
    void RunNotifier$4(RunNotifier, java.util.List, java.util.List) throws Exception;
    protected void notifyListener(RunListener) throws Exception;
}
org/junit/runner/notification/SynchronizedRunListener.class
package org.junit.runner.notification;
final synchronized class SynchronizedRunListener extends RunListener {
    private final RunListener listener;
    private final Object monitor;
    void SynchronizedRunListener(RunListener, Object);
    public void testRunStarted(org.junit.runner.Description) throws Exception;
    public void testRunFinished(org.junit.runner.Result) throws Exception;
    public void testStarted(org.junit.runner.Description) throws Exception;
    public void testFinished(org.junit.runner.Description) throws Exception;
    public void testFailure(Failure) throws Exception;
    public void testAssumptionFailure(Failure);
    public void testIgnored(org.junit.runner.Description) throws Exception;
    public int hashCode();
    public boolean equals(Object);
    public String toString();
}
org/junit/runner/notification/RunNotifier$SafeNotifier.class
package org.junit.runner.notification;
abstract synchronized class RunNotifier$SafeNotifier {
    private final java.util.List currentListeners;
    void RunNotifier$SafeNotifier(RunNotifier);
    void RunNotifier$SafeNotifier(RunNotifier, java.util.List);
    void run();
    protected abstract void notifyListener(RunListener) throws Exception;
}
org/junit/runner/notification/RunNotifier$5.class
package org.junit.runner.notification;
synchronized class RunNotifier$5 extends RunNotifier$SafeNotifier {
    void RunNotifier$5(RunNotifier, Failure);
    protected void notifyListener(RunListener) throws Exception;
}
org/junit/runner/notification/StoppedByUserException.class
package org.junit.runner.notification;
public synchronized class StoppedByUserException extends RuntimeException {
    private static final long serialVersionUID = 1;
    public void StoppedByUserException();
}
org/junit/runner/notification/RunNotifier$6.class
package org.junit.runner.notification;
synchronized class RunNotifier$6 extends RunNotifier$SafeNotifier {
    void RunNotifier$6(RunNotifier, org.junit.runner.Description) throws Exception;
    protected void notifyListener(RunListener) throws Exception;
}
org/junit/runner/notification/RunNotifier$7.class
package org.junit.runner.notification;
synchronized class RunNotifier$7 extends RunNotifier$SafeNotifier {
    void RunNotifier$7(RunNotifier, org.junit.runner.Description) throws Exception;
    protected void notifyListener(RunListener) throws Exception;
}
org/junit/runner/notification/RunListener.class
package org.junit.runner.notification;
public synchronized class RunListener {
    public void RunListener();
    public void testRunStarted(org.junit.runner.Description) throws Exception;
    public void testRunFinished(org.junit.runner.Result) throws Exception;
    public void testStarted(org.junit.runner.Description) throws Exception;
    public void testFinished(org.junit.runner.Description) throws Exception;
    public void testFailure(Failure) throws Exception;
    public void testAssumptionFailure(Failure);
    public void testIgnored(org.junit.runner.Description) throws Exception;
}
org/junit/runner/Description.class
package org.junit.runner;
public synchronized class Description implements java.io.Serializable {
    private static final long serialVersionUID = 1;
    private static final java.util.regex.Pattern METHOD_AND_CLASS_NAME_PATTERN;
    public static final Description EMPTY;
    public static final Description TEST_MECHANISM;
    private final java.util.Collection fChildren;
    private final String fDisplayName;
    private final java.io.Serializable fUniqueId;
    private final annotation.Annotation[] fAnnotations;
    private volatile Class fTestClass;
    public static transient Description createSuiteDescription(String, annotation.Annotation[]);
    public static transient Description createSuiteDescription(String, java.io.Serializable, annotation.Annotation[]);
    public static transient Description createTestDescription(String, String, annotation.Annotation[]);
    public static transient Description createTestDescription(Class, String, annotation.Annotation[]);
    public static Description createTestDescription(Class, String);
    public static Description createTestDescription(String, String, java.io.Serializable);
    private static String formatDisplayName(String, String);
    public static Description createSuiteDescription(Class);
    private transient void Description(Class, String, annotation.Annotation[]);
    private transient void Description(Class, String, java.io.Serializable, annotation.Annotation[]);
    public String getDisplayName();
    public void addChild(Description);
    public java.util.ArrayList getChildren();
    public boolean isSuite();
    public boolean isTest();
    public int testCount();
    public int hashCode();
    public boolean equals(Object);
    public String toString();
    public boolean isEmpty();
    public Description childlessCopy();
    public annotation.Annotation getAnnotation(Class);
    public java.util.Collection getAnnotations();
    public Class getTestClass();
    public String getClassName();
    public String getMethodName();
    private String methodAndClassNamePatternGroupOrDefault(int, String);
    static void ();
}
org/junit/runner/Computer.class
package org.junit.runner;
public synchronized class Computer {
    public void Computer();
    public static Computer serial();
    public Runner getSuite(org.junit.runners.model.RunnerBuilder, Class[]) throws org.junit.runners.model.InitializationError;
    protected Runner getRunner(org.junit.runners.model.RunnerBuilder, Class) throws Throwable;
}
org/junit/validator/AnnotationsValidator$FieldValidator.class
package org.junit.validator;
synchronized class AnnotationsValidator$FieldValidator extends AnnotationsValidator$AnnotatableValidator {
    private void AnnotationsValidator$FieldValidator();
    Iterable getAnnotatablesForTestClass(org.junit.runners.model.TestClass);
    java.util.List validateAnnotatable(AnnotationValidator, org.junit.runners.model.FrameworkField);
}
org/junit/validator/TestClassValidator.class
package org.junit.validator;
public abstract interface TestClassValidator {
    public abstract java.util.List validateTestClass(org.junit.runners.model.TestClass);
}
org/junit/validator/ValidateWith.class
package org.junit.validator;
public abstract interface ValidateWith extends annotation.Annotation {
    public abstract Class value();
}
org/junit/validator/AnnotationsValidator$AnnotatableValidator.class
package org.junit.validator;
abstract synchronized class AnnotationsValidator$AnnotatableValidator {
    private static final AnnotationValidatorFactory ANNOTATION_VALIDATOR_FACTORY;
    private void AnnotationsValidator$AnnotatableValidator();
    abstract Iterable getAnnotatablesForTestClass(org.junit.runners.model.TestClass);
    abstract java.util.List validateAnnotatable(AnnotationValidator, org.junit.runners.model.Annotatable);
    public java.util.List validateTestClass(org.junit.runners.model.TestClass);
    private java.util.List validateAnnotatable(org.junit.runners.model.Annotatable);
    static void ();
}
org/junit/validator/AnnotationsValidator$MethodValidator.class
package org.junit.validator;
synchronized class AnnotationsValidator$MethodValidator extends AnnotationsValidator$AnnotatableValidator {
    private void AnnotationsValidator$MethodValidator();
    Iterable getAnnotatablesForTestClass(org.junit.runners.model.TestClass);
    java.util.List validateAnnotatable(AnnotationValidator, org.junit.runners.model.FrameworkMethod);
}
org/junit/validator/AnnotationsValidator$ClassValidator.class
package org.junit.validator;
synchronized class AnnotationsValidator$ClassValidator extends AnnotationsValidator$AnnotatableValidator {
    private void AnnotationsValidator$ClassValidator();
    Iterable getAnnotatablesForTestClass(org.junit.runners.model.TestClass);
    java.util.List validateAnnotatable(AnnotationValidator, org.junit.runners.model.TestClass);
}
org/junit/validator/AnnotationValidatorFactory.class
package org.junit.validator;
public synchronized class AnnotationValidatorFactory {
    private static final java.util.concurrent.ConcurrentHashMap VALIDATORS_FOR_ANNOTATION_TYPES;
    public void AnnotationValidatorFactory();
    public AnnotationValidator createAnnotationValidator(ValidateWith);
    static void ();
}
org/junit/validator/AnnotationValidator.class
package org.junit.validator;
public abstract synchronized class AnnotationValidator {
    private static final java.util.List NO_VALIDATION_ERRORS;
    public void AnnotationValidator();
    public java.util.List validateAnnotatedClass(org.junit.runners.model.TestClass);
    public java.util.List validateAnnotatedField(org.junit.runners.model.FrameworkField);
    public java.util.List validateAnnotatedMethod(org.junit.runners.model.FrameworkMethod);
    static void ();
}
org/junit/validator/AnnotationsValidator$1.class
package org.junit.validator;
synchronized class AnnotationsValidator$1 {
}
org/junit/validator/AnnotationsValidator.class
package org.junit.validator;
public final synchronized class AnnotationsValidator implements TestClassValidator {
    private static final java.util.List VALIDATORS;
    public void AnnotationsValidator();
    public java.util.List validateTestClass(org.junit.runners.model.TestClass);
    static void ();
}
org/junit/validator/PublicClassValidator.class
package org.junit.validator;
public synchronized class PublicClassValidator implements TestClassValidator {
    private static final java.util.List NO_VALIDATION_ERRORS;
    public void PublicClassValidator();
    public java.util.List validateTestClass(org.junit.runners.model.TestClass);
    static void ();
}
org/junit/ComparisonFailure$1.class
package org.junit;
synchronized class ComparisonFailure$1 {
}
org/junit/Ignore.class
package org.junit;
public abstract interface Ignore extends annotation.Annotation {
    public abstract String value();
}
org/junit/BeforeClass.class
package org.junit;
public abstract interface BeforeClass extends annotation.Annotation {
}
org/junit/Before.class
package org.junit;
public abstract interface Before extends annotation.Annotation {
}
org/junit/Test.class
package org.junit;
public abstract interface Test extends annotation.Annotation {
    public abstract Class expected();
    public abstract long timeout();
}
org/junit/AfterClass.class
package org.junit;
public abstract interface AfterClass extends annotation.Annotation {
}
org/junit/FixMethodOrder.class
package org.junit;
public abstract interface FixMethodOrder extends annotation.Annotation {
    public abstract runners.MethodSorters value();
}
org/junit/ComparisonFailure$ComparisonCompactor.class
package org.junit;
synchronized class ComparisonFailure$ComparisonCompactor {
    private static final String ELLIPSIS = ...;
    private static final String DIFF_END = ];
    private static final String DIFF_START = [;
    private final int contextLength;
    private final String expected;
    private final String actual;
    public void ComparisonFailure$ComparisonCompactor(int, String, String);
    public String compact(String);
    private String sharedPrefix();
    private String sharedSuffix(String);
}
org/junit/internal/ExactComparisonCriteria.class
package org.junit.internal;
public synchronized class ExactComparisonCriteria extends ComparisonCriteria {
    public void ExactComparisonCriteria();
    protected void assertElementsEqual(Object, Object);
}
org/junit/internal/matchers/ThrowableMessageMatcher.class
package org.junit.internal.matchers;
public synchronized class ThrowableMessageMatcher extends org.hamcrest.TypeSafeMatcher {
    private final org.hamcrest.Matcher matcher;
    public void ThrowableMessageMatcher(org.hamcrest.Matcher);
    public void describeTo(org.hamcrest.Description);
    protected boolean matchesSafely(Throwable);
    protected void describeMismatchSafely(Throwable, org.hamcrest.Description);
    public static org.hamcrest.Matcher hasMessage(org.hamcrest.Matcher);
}
org/junit/internal/matchers/TypeSafeMatcher.class
package org.junit.internal.matchers;
public abstract synchronized class TypeSafeMatcher extends org.hamcrest.BaseMatcher {
    private Class expectedType;
    public abstract boolean matchesSafely(Object);
    protected void TypeSafeMatcher();
    private static Class findExpectedType(Class);
    private static boolean isMatchesSafelyMethod(reflect.Method);
    protected void TypeSafeMatcher(Class);
    public final boolean matches(Object);
}
org/junit/internal/matchers/StacktracePrintingMatcher.class
package org.junit.internal.matchers;
public synchronized class StacktracePrintingMatcher extends org.hamcrest.TypeSafeMatcher {
    private final org.hamcrest.Matcher throwableMatcher;
    public void StacktracePrintingMatcher(org.hamcrest.Matcher);
    public void describeTo(org.hamcrest.Description);
    protected boolean matchesSafely(Throwable);
    protected void describeMismatchSafely(Throwable, org.hamcrest.Description);
    private String readStacktrace(Throwable);
    public static org.hamcrest.Matcher isThrowable(org.hamcrest.Matcher);
    public static org.hamcrest.Matcher isException(org.hamcrest.Matcher);
}
org/junit/internal/matchers/ThrowableCauseMatcher.class
package org.junit.internal.matchers;
public synchronized class ThrowableCauseMatcher extends org.hamcrest.TypeSafeMatcher {
    private final org.hamcrest.Matcher causeMatcher;
    public void ThrowableCauseMatcher(org.hamcrest.Matcher);
    public void describeTo(org.hamcrest.Description);
    protected boolean matchesSafely(Throwable);
    protected void describeMismatchSafely(Throwable, org.hamcrest.Description);
    public static org.hamcrest.Matcher hasCause(org.hamcrest.Matcher);
}
org/junit/internal/ArrayComparisonFailure.class
package org.junit.internal;
public synchronized class ArrayComparisonFailure extends AssertionError {
    private static final long serialVersionUID = 1;
    private final java.util.List fIndices;
    private final String fMessage;
    public void ArrayComparisonFailure(String, AssertionError, int);
    public void addDimension(int);
    public String getMessage();
    public String toString();
}
org/junit/internal/InexactComparisonCriteria.class
package org.junit.internal;
public synchronized class InexactComparisonCriteria extends ComparisonCriteria {
    public Object fDelta;
    public void InexactComparisonCriteria(double);
    public void InexactComparisonCriteria(float);
    protected void assertElementsEqual(Object, Object);
}
org/junit/internal/TextListener.class
package org.junit.internal;
public synchronized class TextListener extends org.junit.runner.notification.RunListener {
    private final java.io.PrintStream writer;
    public void TextListener(JUnitSystem);
    public void TextListener(java.io.PrintStream);
    public void testRunFinished(org.junit.runner.Result);
    public void testStarted(org.junit.runner.Description);
    public void testFailure(org.junit.runner.notification.Failure);
    public void testIgnored(org.junit.runner.Description);
    private java.io.PrintStream getWriter();
    protected void printHeader(long);
    protected void printFailures(org.junit.runner.Result);
    protected void printFailure(org.junit.runner.notification.Failure, String);
    protected void printFooter(org.junit.runner.Result);
    protected String elapsedTimeAsString(long);
}
org/junit/internal/MethodSorter.class
package org.junit.internal;
public synchronized class MethodSorter {
    public static final java.util.Comparator DEFAULT;
    public static final java.util.Comparator NAME_ASCENDING;
    public static reflect.Method[] getDeclaredMethods(Class);
    private void MethodSorter();
    private static java.util.Comparator getSorter(org.junit.FixMethodOrder);
    static void ();
}
org/junit/internal/JUnitSystem.class
package org.junit.internal;
public abstract interface JUnitSystem {
    public abstract void exit(int);
    public abstract java.io.PrintStream out();
}
org/junit/internal/runners/JUnit38ClassRunner$OldTestClassAdaptingListener.class
package org.junit.internal.runners;
final synchronized class JUnit38ClassRunner$OldTestClassAdaptingListener implements junit.framework.TestListener {
    private final org.junit.runner.notification.RunNotifier notifier;
    private void JUnit38ClassRunner$OldTestClassAdaptingListener(org.junit.runner.notification.RunNotifier);
    public void endTest(junit.framework.Test);
    public void startTest(junit.framework.Test);
    public void addError(junit.framework.Test, Throwable);
    private org.junit.runner.Description asDescription(junit.framework.Test);
    private Class getEffectiveClass(junit.framework.Test);
    private String getName(junit.framework.Test);
    public void addFailure(junit.framework.Test, junit.framework.AssertionFailedError);
}
org/junit/internal/runners/JUnit4ClassRunner$1.class
package org.junit.internal.runners;
synchronized class JUnit4ClassRunner$1 implements Runnable {
    void JUnit4ClassRunner$1(JUnit4ClassRunner, org.junit.runner.notification.RunNotifier);
    public void run();
}
org/junit/internal/runners/MethodRoadie$2.class
package org.junit.internal.runners;
synchronized class MethodRoadie$2 implements Runnable {
    void MethodRoadie$2(MethodRoadie);
    public void run();
}
org/junit/internal/runners/TestMethod.class
package org.junit.internal.runners;
public synchronized class TestMethod {
    private final reflect.Method method;
    private TestClass testClass;
    public void TestMethod(reflect.Method, TestClass);
    public boolean isIgnored();
    public long getTimeout();
    protected Class getExpectedException();
    boolean isUnexpected(Throwable);
    boolean expectsException();
    java.util.List getBefores();
    java.util.List getAfters();
    public void invoke(Object) throws IllegalArgumentException, IllegalAccessException, reflect.InvocationTargetException;
}
org/junit/internal/runners/rules/RuleMemberValidator.class
package org.junit.internal.runners.rules;
public synchronized class RuleMemberValidator {
    public static final RuleMemberValidator CLASS_RULE_VALIDATOR;
    public static final RuleMemberValidator RULE_VALIDATOR;
    public static final RuleMemberValidator CLASS_RULE_METHOD_VALIDATOR;
    public static final RuleMemberValidator RULE_METHOD_VALIDATOR;
    private final Class annotation;
    private final boolean methods;
    private final java.util.List validatorStrategies;
    void RuleMemberValidator(RuleMemberValidator$Builder);
    public void validate(org.junit.runners.model.TestClass, java.util.List);
    private void validateMember(org.junit.runners.model.FrameworkMember, java.util.List);
    private static RuleMemberValidator$Builder classRuleValidatorBuilder();
    private static RuleMemberValidator$Builder testRuleValidatorBuilder();
    private static boolean isRuleType(org.junit.runners.model.FrameworkMember);
    private static boolean isTestRule(org.junit.runners.model.FrameworkMember);
    private static boolean isMethodRule(org.junit.runners.model.FrameworkMember);
    static void ();
}
org/junit/internal/runners/rules/RuleMemberValidator$MethodMustBeARule.class
package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$MethodMustBeARule implements RuleMemberValidator$RuleValidator {
    private void RuleMemberValidator$MethodMustBeARule();
    public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}
org/junit/internal/runners/rules/RuleMemberValidator$MemberMustBePublic.class
package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$MemberMustBePublic implements RuleMemberValidator$RuleValidator {
    private void RuleMemberValidator$MemberMustBePublic();
    public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}
org/junit/internal/runners/rules/ValidationError.class
package org.junit.internal.runners.rules;
synchronized class ValidationError extends Exception {
    public void ValidationError(org.junit.runners.model.FrameworkMember, Class, String);
}
org/junit/internal/runners/rules/RuleMemberValidator$MemberMustBeStatic.class
package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$MemberMustBeStatic implements RuleMemberValidator$RuleValidator {
    private void RuleMemberValidator$MemberMustBeStatic();
    public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}
org/junit/internal/runners/rules/RuleMemberValidator$Builder.class
package org.junit.internal.runners.rules;
synchronized class RuleMemberValidator$Builder {
    private final Class annotation;
    private boolean methods;
    private final java.util.List validators;
    private void RuleMemberValidator$Builder(Class);
    RuleMemberValidator$Builder forMethods();
    RuleMemberValidator$Builder withValidator(RuleMemberValidator$RuleValidator);
    RuleMemberValidator build();
}
org/junit/internal/runners/rules/RuleMemberValidator$MemberMustBeNonStaticOrAlsoClassRule.class
package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$MemberMustBeNonStaticOrAlsoClassRule implements RuleMemberValidator$RuleValidator {
    private void RuleMemberValidator$MemberMustBeNonStaticOrAlsoClassRule();
    public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}
org/junit/internal/runners/rules/RuleMemberValidator$FieldMustBeARule.class
package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$FieldMustBeARule implements RuleMemberValidator$RuleValidator {
    private void RuleMemberValidator$FieldMustBeARule();
    public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}
org/junit/internal/runners/rules/RuleMemberValidator$MethodMustBeATestRule.class
package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$MethodMustBeATestRule implements RuleMemberValidator$RuleValidator {
    private void RuleMemberValidator$MethodMustBeATestRule();
    public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}
org/junit/internal/runners/rules/RuleMemberValidator$RuleValidator.class
package org.junit.internal.runners.rules;
abstract interface RuleMemberValidator$RuleValidator {
    public abstract void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}
org/junit/internal/runners/rules/RuleMemberValidator$1.class
package org.junit.internal.runners.rules;
synchronized class RuleMemberValidator$1 {
}
org/junit/internal/runners/rules/RuleMemberValidator$DeclaringClassMustBePublic.class
package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$DeclaringClassMustBePublic implements RuleMemberValidator$RuleValidator {
    private void RuleMemberValidator$DeclaringClassMustBePublic();
    public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
    private boolean isDeclaringClassPublic(org.junit.runners.model.FrameworkMember);
}
org/junit/internal/runners/rules/RuleMemberValidator$FieldMustBeATestRule.class
package org.junit.internal.runners.rules;
final synchronized class RuleMemberValidator$FieldMustBeATestRule implements RuleMemberValidator$RuleValidator {
    private void RuleMemberValidator$FieldMustBeATestRule();
    public void validate(org.junit.runners.model.FrameworkMember, Class, java.util.List);
}
org/junit/internal/runners/MethodRoadie$1.class
package org.junit.internal.runners;
synchronized class MethodRoadie$1 implements Runnable {
    void MethodRoadie$1(MethodRoadie, long);
    public void run();
}
org/junit/internal/runners/TestClass.class
package org.junit.internal.runners;
public synchronized class TestClass {
    private final Class klass;
    public void TestClass(Class);
    public java.util.List getTestMethods();
    java.util.List getBefores();
    java.util.List getAfters();
    public java.util.List getAnnotatedMethods(Class);
    private boolean runsTopToBottom(Class);
    private boolean isShadowed(reflect.Method, java.util.List);
    private boolean isShadowed(reflect.Method, reflect.Method);
    private java.util.List getSuperClasses(Class);
    public reflect.Constructor getConstructor() throws SecurityException, NoSuchMethodException;
    public Class getJavaClass();
    public String getName();
}
org/junit/internal/runners/ErrorReportingRunner.class
package org.junit.internal.runners;
public synchronized class ErrorReportingRunner extends org.junit.runner.Runner {
    private final java.util.List causes;
    private final Class testClass;
    public void ErrorReportingRunner(Class, Throwable);
    public org.junit.runner.Description getDescription();
    public void run(org.junit.runner.notification.RunNotifier);
    private java.util.List getCauses(Throwable);
    private org.junit.runner.Description describeCause(Throwable);
    private void runCause(Throwable, org.junit.runner.notification.RunNotifier);
}
org/junit/internal/runners/JUnit4ClassRunner.class
package org.junit.internal.runners;
public synchronized class JUnit4ClassRunner extends org.junit.runner.Runner implements org.junit.runner.manipulation.Filterable, org.junit.runner.manipulation.Sortable {
    private final java.util.List testMethods;
    private TestClass testClass;
    public void JUnit4ClassRunner(Class) throws InitializationError;
    protected java.util.List getTestMethods();
    protected void validate() throws InitializationError;
    public void run(org.junit.runner.notification.RunNotifier);
    protected void runMethods(org.junit.runner.notification.RunNotifier);
    public org.junit.runner.Description getDescription();
    protected annotation.Annotation[] classAnnotations();
    protected String getName();
    protected Object createTest() throws Exception;
    protected void invokeTestMethod(reflect.Method, org.junit.runner.notification.RunNotifier);
    private void testAborted(org.junit.runner.notification.RunNotifier, org.junit.runner.Description, Throwable);
    protected TestMethod wrapMethod(reflect.Method);
    protected String testName(reflect.Method);
    protected org.junit.runner.Description methodDescription(reflect.Method);
    protected annotation.Annotation[] testAnnotations(reflect.Method);
    public void filter(org.junit.runner.manipulation.Filter) throws org.junit.runner.manipulation.NoTestsRemainException;
    public void sort(org.junit.runner.manipulation.Sorter);
    protected TestClass getTestClass();
}
org/junit/internal/runners/FailedBefore.class
package org.junit.internal.runners;
synchronized class FailedBefore extends Exception {
    private static final long serialVersionUID = 1;
    void FailedBefore();
}
org/junit/internal/runners/statements/FailOnTimeout$1.class
package org.junit.internal.runners.statements;
synchronized class FailOnTimeout$1 {
}
org/junit/internal/runners/statements/Fail.class
package org.junit.internal.runners.statements;
public synchronized class Fail extends org.junit.runners.model.Statement {
    private final Throwable error;
    public void Fail(Throwable);
    public void evaluate() throws Throwable;
}
org/junit/internal/runners/statements/FailOnTimeout.class
package org.junit.internal.runners.statements;
public synchronized class FailOnTimeout extends org.junit.runners.model.Statement {
    private final org.junit.runners.model.Statement originalStatement;
    private final java.util.concurrent.TimeUnit timeUnit;
    private final long timeout;
    private final boolean lookForStuckThread;
    private volatile ThreadGroup threadGroup;
    public static FailOnTimeout$Builder builder();
    public void FailOnTimeout(org.junit.runners.model.Statement, long);
    private void FailOnTimeout(FailOnTimeout$Builder, org.junit.runners.model.Statement);
    public void evaluate() throws Throwable;
    private Throwable getResult(java.util.concurrent.FutureTask, Thread);
    private Exception createTimeoutException(Thread);
    private StackTraceElement[] getStackTrace(Thread);
    private Thread getStuckThread(Thread);
    private Thread[] getThreadArray(ThreadGroup);
    private Thread[] copyThreads(Thread[], int);
    private long cpuTime(Thread);
}
org/junit/internal/runners/statements/RunAfters.class
package org.junit.internal.runners.statements;
public synchronized class RunAfters extends org.junit.runners.model.Statement {
    private final org.junit.runners.model.Statement next;
    private final Object target;
    private final java.util.List afters;
    public void RunAfters(org.junit.runners.model.Statement, java.util.List, Object);
    public void evaluate() throws Throwable;
}
org/junit/internal/runners/statements/RunBefores.class
package org.junit.internal.runners.statements;
public synchronized class RunBefores extends org.junit.runners.model.Statement {
    private final org.junit.runners.model.Statement next;
    private final Object target;
    private final java.util.List befores;
    public void RunBefores(org.junit.runners.model.Statement, java.util.List, Object);
    public void evaluate() throws Throwable;
}
org/junit/internal/runners/statements/ExpectException.class
package org.junit.internal.runners.statements;
public synchronized class ExpectException extends org.junit.runners.model.Statement {
    private final org.junit.runners.model.Statement next;
    private final Class expected;
    public void ExpectException(org.junit.runners.model.Statement, Class);
    public void evaluate() throws Exception;
}
org/junit/internal/runners/statements/InvokeMethod.class
package org.junit.internal.runners.statements;
public synchronized class InvokeMethod extends org.junit.runners.model.Statement {
    private final org.junit.runners.model.FrameworkMethod testMethod;
    private final Object target;
    public void InvokeMethod(org.junit.runners.model.FrameworkMethod, Object);
    public void evaluate() throws Throwable;
}
org/junit/internal/runners/statements/FailOnTimeout$Builder.class
package org.junit.internal.runners.statements;
public synchronized class FailOnTimeout$Builder {
    private boolean lookForStuckThread;
    private long timeout;
    private java.util.concurrent.TimeUnit unit;
    private void FailOnTimeout$Builder();
    public FailOnTimeout$Builder withTimeout(long, java.util.concurrent.TimeUnit);
    public FailOnTimeout$Builder withLookingForStuckThread(boolean);
    public FailOnTimeout build(org.junit.runners.model.Statement);
}
org/junit/internal/runners/statements/FailOnTimeout$CallableStatement.class
package org.junit.internal.runners.statements;
synchronized class FailOnTimeout$CallableStatement implements java.util.concurrent.Callable {
    private final java.util.concurrent.CountDownLatch startLatch;
    private void FailOnTimeout$CallableStatement(FailOnTimeout);
    public Throwable call() throws Exception;
    public void awaitStarted() throws InterruptedException;
}
org/junit/internal/runners/JUnit4ClassRunner$2.class
package org.junit.internal.runners;
synchronized class JUnit4ClassRunner$2 implements java.util.Comparator {
    void JUnit4ClassRunner$2(JUnit4ClassRunner, org.junit.runner.manipulation.Sorter);
    public int compare(reflect.Method, reflect.Method);
}
org/junit/internal/runners/MethodValidator.class
package org.junit.internal.runners;
public synchronized class MethodValidator {
    private final java.util.List errors;
    private TestClass testClass;
    public void MethodValidator(TestClass);
    public void validateInstanceMethods();
    public void validateStaticMethods();
    public java.util.List validateMethodsForDefaultRunner();
    public void assertValid() throws InitializationError;
    public void validateNoArgConstructor();
    private void validateTestMethods(Class, boolean);
}
org/junit/internal/runners/JUnit38ClassRunner.class
package org.junit.internal.runners;
public synchronized class JUnit38ClassRunner extends org.junit.runner.Runner implements org.junit.runner.manipulation.Filterable, org.junit.runner.manipulation.Sortable {
    private volatile junit.framework.Test test;
    public void JUnit38ClassRunner(Class);
    public void JUnit38ClassRunner(junit.framework.Test);
    public void run(org.junit.runner.notification.RunNotifier);
    public junit.framework.TestListener createAdaptingListener(org.junit.runner.notification.RunNotifier);
    public org.junit.runner.Description getDescription();
    private static org.junit.runner.Description makeDescription(junit.framework.Test);
    private static annotation.Annotation[] getAnnotations(junit.framework.TestCase);
    private static String createSuiteDescription(junit.framework.TestSuite);
    public void filter(org.junit.runner.manipulation.Filter) throws org.junit.runner.manipulation.NoTestsRemainException;
    public void sort(org.junit.runner.manipulation.Sorter);
    private void setTest(junit.framework.Test);
    private junit.framework.Test getTest();
}
org/junit/internal/runners/SuiteMethod.class
package org.junit.internal.runners;
public synchronized class SuiteMethod extends JUnit38ClassRunner {
    public void SuiteMethod(Class) throws Throwable;
    public static junit.framework.Test testFromSuiteMethod(Class) throws Throwable;
}
org/junit/internal/runners/MethodRoadie.class
package org.junit.internal.runners;
public synchronized class MethodRoadie {
    private final Object test;
    private final org.junit.runner.notification.RunNotifier notifier;
    private final org.junit.runner.Description description;
    private TestMethod testMethod;
    public void MethodRoadie(Object, TestMethod, org.junit.runner.notification.RunNotifier, org.junit.runner.Description);
    public void run();
    private void runWithTimeout(long);
    public void runTest();
    public void runBeforesThenTestThenAfters(Runnable);
    protected void runTestMethod();
    private void runBefores() throws FailedBefore;
    private void runAfters();
    protected void addFailure(Throwable);
}
org/junit/internal/runners/InitializationError.class
package org.junit.internal.runners;
public synchronized class InitializationError extends Exception {
    private static final long serialVersionUID = 1;
    private final java.util.List fErrors;
    public void InitializationError(java.util.List);
    public transient void InitializationError(Throwable[]);
    public void InitializationError(String);
    public java.util.List getCauses();
}
org/junit/internal/runners/ClassRoadie.class
package org.junit.internal.runners;
public synchronized class ClassRoadie {
    private org.junit.runner.notification.RunNotifier notifier;
    private TestClass testClass;
    private org.junit.runner.Description description;
    private final Runnable runnable;
    public void ClassRoadie(org.junit.runner.notification.RunNotifier, TestClass, org.junit.runner.Description, Runnable);
    protected void runUnprotected();
    protected void addFailure(Throwable);
    public void runProtected();
    private void runBefores() throws FailedBefore;
    private void runAfters();
}
org/junit/internal/runners/JUnit38ClassRunner$1.class
package org.junit.internal.runners;
synchronized class JUnit38ClassRunner$1 {
}
org/junit/internal/runners/MethodRoadie$1$1.class
package org.junit.internal.runners;
synchronized class MethodRoadie$1$1 implements java.util.concurrent.Callable {
    void MethodRoadie$1$1(MethodRoadie$1);
    public Object call() throws Exception;
}
org/junit/internal/runners/model/ReflectiveCallable.class
package org.junit.internal.runners.model;
public abstract synchronized class ReflectiveCallable {
    public void ReflectiveCallable();
    public Object run() throws Throwable;
    protected abstract Object runReflectiveCall() throws Throwable;
}
org/junit/internal/runners/model/EachTestNotifier.class
package org.junit.internal.runners.model;
public synchronized class EachTestNotifier {
    private final org.junit.runner.notification.RunNotifier notifier;
    private final org.junit.runner.Description description;
    public void EachTestNotifier(org.junit.runner.notification.RunNotifier, org.junit.runner.Description);
    public void addFailure(Throwable);
    private void addMultipleFailureException(org.junit.runners.model.MultipleFailureException);
    public void addFailedAssumption(org.junit.internal.AssumptionViolatedException);
    public void fireTestFinished();
    public void fireTestStarted();
    public void fireTestIgnored();
}
org/junit/internal/runners/model/MultipleFailureException.class
package org.junit.internal.runners.model;
public synchronized class MultipleFailureException extends org.junit.runners.model.MultipleFailureException {
    private static final long serialVersionUID = 1;
    public void MultipleFailureException(java.util.List);
}
org/junit/internal/requests/FilterRequest.class
package org.junit.internal.requests;
public final synchronized class FilterRequest extends org.junit.runner.Request {
    private final org.junit.runner.Request request;
    private final org.junit.runner.manipulation.Filter fFilter;
    public void FilterRequest(org.junit.runner.Request, org.junit.runner.manipulation.Filter);
    public org.junit.runner.Runner getRunner();
}
org/junit/internal/requests/ClassRequest.class
package org.junit.internal.requests;
public synchronized class ClassRequest extends org.junit.runner.Request {
    private final Object runnerLock;
    private final Class fTestClass;
    private final boolean canUseSuiteMethod;
    private volatile org.junit.runner.Runner runner;
    public void ClassRequest(Class, boolean);
    public void ClassRequest(Class);
    public org.junit.runner.Runner getRunner();
}
org/junit/internal/requests/SortingRequest.class
package org.junit.internal.requests;
public synchronized class SortingRequest extends org.junit.runner.Request {
    private final org.junit.runner.Request request;
    private final java.util.Comparator comparator;
    public void SortingRequest(org.junit.runner.Request, java.util.Comparator);
    public org.junit.runner.Runner getRunner();
}
org/junit/internal/AssumptionViolatedException.class
package org.junit.internal;
public synchronized class AssumptionViolatedException extends RuntimeException implements org.hamcrest.SelfDescribing {
    private static final long serialVersionUID = 2;
    private final String fAssumption;
    private final boolean fValueMatcher;
    private final Object fValue;
    private final org.hamcrest.Matcher fMatcher;
    public void AssumptionViolatedException(String, boolean, Object, org.hamcrest.Matcher);
    public void AssumptionViolatedException(Object, org.hamcrest.Matcher);
    public void AssumptionViolatedException(String, Object, org.hamcrest.Matcher);
    public void AssumptionViolatedException(String);
    public void AssumptionViolatedException(String, Throwable);
    public String getMessage();
    public void describeTo(org.hamcrest.Description);
}
org/junit/internal/RealSystem.class
package org.junit.internal;
public synchronized class RealSystem implements JUnitSystem {
    public void RealSystem();
    public void exit(int);
    public java.io.PrintStream out();
}
org/junit/internal/MethodSorter$2.class
package org.junit.internal;
synchronized class MethodSorter$2 implements java.util.Comparator {
    void MethodSorter$2();
    public int compare(reflect.Method, reflect.Method);
}
org/junit/internal/ComparisonCriteria.class
package org.junit.internal;
public abstract synchronized class ComparisonCriteria {
    public void ComparisonCriteria();
    public void arrayEquals(String, Object, Object) throws ArrayComparisonFailure;
    private boolean isArray(Object);
    private int assertArraysAreSameLength(Object, Object, String);
    protected abstract void assertElementsEqual(Object, Object);
}
org/junit/internal/Throwables.class
package org.junit.internal;
public final synchronized class Throwables {
    private void Throwables();
    public static Exception rethrowAsException(Throwable) throws Exception;
    private static void rethrow(Throwable) throws Throwable;
}
org/junit/internal/MethodSorter$1.class
package org.junit.internal;
synchronized class MethodSorter$1 implements java.util.Comparator {
    void MethodSorter$1();
    public int compare(reflect.Method, reflect.Method);
}
org/junit/internal/Classes.class
package org.junit.internal;
public synchronized class Classes {
    public void Classes();
    public static Class getClass(String) throws ClassNotFoundException;
}
org/junit/internal/builders/IgnoredClassRunner.class
package org.junit.internal.builders;
public synchronized class IgnoredClassRunner extends org.junit.runner.Runner {
    private final Class clazz;
    public void IgnoredClassRunner(Class);
    public void run(org.junit.runner.notification.RunNotifier);
    public org.junit.runner.Description getDescription();
}
org/junit/internal/builders/JUnit4Builder.class
package org.junit.internal.builders;
public synchronized class JUnit4Builder extends org.junit.runners.model.RunnerBuilder {
    public void JUnit4Builder();
    public org.junit.runner.Runner runnerForClass(Class) throws Throwable;
}
org/junit/internal/builders/AnnotatedBuilder.class
package org.junit.internal.builders;
public synchronized class AnnotatedBuilder extends org.junit.runners.model.RunnerBuilder {
    private static final String CONSTRUCTOR_ERROR_FORMAT = Custom runner class %s should have a public constructor with signature %s(Class testClass);
    private final org.junit.runners.model.RunnerBuilder suiteBuilder;
    public void AnnotatedBuilder(org.junit.runners.model.RunnerBuilder);
    public org.junit.runner.Runner runnerForClass(Class) throws Exception;
    private Class getEnclosingClassForNonStaticMemberClass(Class);
    public org.junit.runner.Runner buildRunner(Class, Class) throws Exception;
}
org/junit/internal/builders/IgnoredBuilder.class
package org.junit.internal.builders;
public synchronized class IgnoredBuilder extends org.junit.runners.model.RunnerBuilder {
    public void IgnoredBuilder();
    public org.junit.runner.Runner runnerForClass(Class);
}
org/junit/internal/builders/JUnit3Builder.class
package org.junit.internal.builders;
public synchronized class JUnit3Builder extends org.junit.runners.model.RunnerBuilder {
    public void JUnit3Builder();
    public org.junit.runner.Runner runnerForClass(Class) throws Throwable;
    boolean isPre4Test(Class);
}
org/junit/internal/builders/AllDefaultPossibilitiesBuilder.class
package org.junit.internal.builders;
public synchronized class AllDefaultPossibilitiesBuilder extends org.junit.runners.model.RunnerBuilder {
    private final boolean canUseSuiteMethod;
    public void AllDefaultPossibilitiesBuilder(boolean);
    public org.junit.runner.Runner runnerForClass(Class) throws Throwable;
    protected JUnit4Builder junit4Builder();
    protected JUnit3Builder junit3Builder();
    protected AnnotatedBuilder annotatedBuilder();
    protected IgnoredBuilder ignoredBuilder();
    protected org.junit.runners.model.RunnerBuilder suiteMethodBuilder();
}
org/junit/internal/builders/NullBuilder.class
package org.junit.internal.builders;
public synchronized class NullBuilder extends org.junit.runners.model.RunnerBuilder {
    public void NullBuilder();
    public org.junit.runner.Runner runnerForClass(Class) throws Throwable;
}
org/junit/internal/builders/SuiteMethodBuilder.class
package org.junit.internal.builders;
public synchronized class SuiteMethodBuilder extends org.junit.runners.model.RunnerBuilder {
    public void SuiteMethodBuilder();
    public org.junit.runner.Runner runnerForClass(Class) throws Throwable;
    public boolean hasSuiteMethod(Class);
}
org/junit/experimental/results/ResultMatchers$1.class
package org.junit.experimental.results;
synchronized class ResultMatchers$1 extends org.hamcrest.TypeSafeMatcher {
    void ResultMatchers$1(int);
    public void describeTo(org.hamcrest.Description);
    public boolean matchesSafely(PrintableResult);
}
org/junit/experimental/results/ResultMatchers$2.class
package org.junit.experimental.results;
synchronized class ResultMatchers$2 extends org.hamcrest.BaseMatcher {
    void ResultMatchers$2(String);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
}
org/junit/experimental/results/FailureList.class
package org.junit.experimental.results;
synchronized class FailureList {
    private final java.util.List failures;
    public void FailureList(java.util.List);
    public org.junit.runner.Result result();
}
org/junit/experimental/results/ResultMatchers$3.class
package org.junit.experimental.results;
synchronized class ResultMatchers$3 extends org.hamcrest.BaseMatcher {
    void ResultMatchers$3(String);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
}
org/junit/experimental/results/ResultMatchers.class
package org.junit.experimental.results;
public synchronized class ResultMatchers {
    public void ResultMatchers();
    public static org.hamcrest.Matcher isSuccessful();
    public static org.hamcrest.Matcher failureCountIs(int);
    public static org.hamcrest.Matcher hasSingleFailureContaining(String);
    public static org.hamcrest.Matcher hasFailureContaining(String);
}
org/junit/experimental/results/PrintableResult.class
package org.junit.experimental.results;
public synchronized class PrintableResult {
    private org.junit.runner.Result result;
    public static PrintableResult testResult(Class);
    public static PrintableResult testResult(org.junit.runner.Request);
    public void PrintableResult(java.util.List);
    private void PrintableResult(org.junit.runner.Result);
    public int failureCount();
    public String toString();
}
org/junit/experimental/ParallelComputer$1.class
package org.junit.experimental;
synchronized class ParallelComputer$1 implements org.junit.runners.model.RunnerScheduler {
    private final java.util.concurrent.ExecutorService fService;
    void ParallelComputer$1();
    public void schedule(Runnable);
    public void finished();
}
org/junit/experimental/max/MaxHistory$RememberingListener.class
package org.junit.experimental.max;
final synchronized class MaxHistory$RememberingListener extends org.junit.runner.notification.RunListener {
    private long overallStart;
    private java.util.Map starts;
    private void MaxHistory$RememberingListener(MaxHistory);
    public void testStarted(org.junit.runner.Description) throws Exception;
    public void testFinished(org.junit.runner.Description) throws Exception;
    public void testFailure(org.junit.runner.notification.Failure) throws Exception;
    public void testRunFinished(org.junit.runner.Result) throws Exception;
}
org/junit/experimental/max/MaxCore.class
package org.junit.experimental.max;
public synchronized class MaxCore {
    private static final String MALFORMED_JUNIT_3_TEST_CLASS_PREFIX = malformed JUnit 3 test class: ;
    private final MaxHistory history;
    public static MaxCore forFolder(String);
    public static MaxCore storedLocally(java.io.File);
    private void MaxCore(java.io.File);
    public org.junit.runner.Result run(Class);
    public org.junit.runner.Result run(org.junit.runner.Request);
    public org.junit.runner.Result run(org.junit.runner.Request, org.junit.runner.JUnitCore);
    public org.junit.runner.Request sortRequest(org.junit.runner.Request);
    private org.junit.runner.Request constructLeafRequest(java.util.List);
    private org.junit.runner.Runner buildRunner(org.junit.runner.Description);
    private Class getMalformedTestClass(org.junit.runner.Description);
    public java.util.List sortedLeavesForTest(org.junit.runner.Request);
    private java.util.List findLeaves(org.junit.runner.Request);
    private void findLeaves(org.junit.runner.Description, org.junit.runner.Description, java.util.List);
}
org/junit/experimental/max/MaxHistory$1.class
package org.junit.experimental.max;
synchronized class MaxHistory$1 {
}
org/junit/experimental/max/MaxHistory$TestComparator.class
package org.junit.experimental.max;
synchronized class MaxHistory$TestComparator implements java.util.Comparator {
    private void MaxHistory$TestComparator(MaxHistory);
    public int compare(org.junit.runner.Description, org.junit.runner.Description);
    private Long getFailure(org.junit.runner.Description);
}
org/junit/experimental/max/MaxCore$1.class
package org.junit.experimental.max;
synchronized class MaxCore$1 extends org.junit.runner.Request {
    void MaxCore$1(MaxCore, java.util.List);
    public org.junit.runner.Runner getRunner();
}
org/junit/experimental/max/MaxCore$1$1.class
package org.junit.experimental.max;
synchronized class MaxCore$1$1 extends org.junit.runners.Suite {
    void MaxCore$1$1(MaxCore$1, Class, java.util.List) throws org.junit.runners.model.InitializationError;
}
org/junit/experimental/max/CouldNotReadCoreException.class
package org.junit.experimental.max;
public synchronized class CouldNotReadCoreException extends Exception {
    private static final long serialVersionUID = 1;
    public void CouldNotReadCoreException(Throwable);
}
org/junit/experimental/max/MaxHistory.class
package org.junit.experimental.max;
public synchronized class MaxHistory implements java.io.Serializable {
    private static final long serialVersionUID = 1;
    private final java.util.Map fDurations;
    private final java.util.Map fFailureTimestamps;
    private final java.io.File fHistoryStore;
    public static MaxHistory forFolder(java.io.File);
    private static MaxHistory readHistory(java.io.File) throws CouldNotReadCoreException;
    private void MaxHistory(java.io.File);
    private void save() throws java.io.IOException;
    Long getFailureTimestamp(org.junit.runner.Description);
    void putTestFailureTimestamp(org.junit.runner.Description, long);
    boolean isNewTest(org.junit.runner.Description);
    Long getTestDuration(org.junit.runner.Description);
    void putTestDuration(org.junit.runner.Description, long);
    public org.junit.runner.notification.RunListener listener();
    public java.util.Comparator testComparator();
}
org/junit/experimental/ParallelComputer.class
package org.junit.experimental;
public synchronized class ParallelComputer extends org.junit.runner.Computer {
    private final boolean classes;
    private final boolean methods;
    public void ParallelComputer(boolean, boolean);
    public static org.junit.runner.Computer classes();
    public static org.junit.runner.Computer methods();
    private static org.junit.runner.Runner parallelize(org.junit.runner.Runner);
    public org.junit.runner.Runner getSuite(org.junit.runners.model.RunnerBuilder, Class[]) throws org.junit.runners.model.InitializationError;
    protected org.junit.runner.Runner getRunner(org.junit.runners.model.RunnerBuilder, Class) throws Throwable;
}
org/junit/experimental/theories/ParameterSignature.class
package org.junit.experimental.theories;
public synchronized class ParameterSignature {
    private static final java.util.Map CONVERTABLE_TYPES_MAP;
    private final Class type;
    private final annotation.Annotation[] annotations;
    private static java.util.Map buildConvertableTypesMap();
    private static void putSymmetrically(java.util.Map, Object, Object);
    public static java.util.ArrayList signatures(reflect.Method);
    public static java.util.List signatures(reflect.Constructor);
    private static java.util.ArrayList signatures(Class[], annotation.Annotation[][]);
    private void ParameterSignature(Class, annotation.Annotation[]);
    public boolean canAcceptValue(Object);
    public boolean canAcceptType(Class);
    public boolean canPotentiallyAcceptType(Class);
    private boolean isAssignableViaTypeConversion(Class, Class);
    public Class getType();
    public java.util.List getAnnotations();
    public boolean hasAnnotation(Class);
    public annotation.Annotation findDeepAnnotation(Class);
    private annotation.Annotation findDeepAnnotation(annotation.Annotation[], Class, int);
    public annotation.Annotation getAnnotation(Class);
    static void ();
}
org/junit/experimental/theories/Theories$TheoryAnchor$2.class
package org.junit.experimental.theories;
synchronized class Theories$TheoryAnchor$2 extends org.junit.runners.model.Statement {
    void Theories$TheoryAnchor$2(Theories$TheoryAnchor, internal.Assignments, org.junit.runners.model.FrameworkMethod, Object) throws Throwable;
    public void evaluate() throws Throwable;
}
org/junit/experimental/theories/Theories$TheoryAnchor.class
package org.junit.experimental.theories;
public synchronized class Theories$TheoryAnchor extends org.junit.runners.model.Statement {
    private int successes;
    private final org.junit.runners.model.FrameworkMethod testMethod;
    private final org.junit.runners.model.TestClass testClass;
    private java.util.List fInvalidParameters;
    public void Theories$TheoryAnchor(org.junit.runners.model.FrameworkMethod, org.junit.runners.model.TestClass);
    private org.junit.runners.model.TestClass getTestClass();
    public void evaluate() throws Throwable;
    protected void runWithAssignment(internal.Assignments) throws Throwable;
    protected void runWithIncompleteAssignment(internal.Assignments) throws Throwable;
    protected void runWithCompleteAssignment(internal.Assignments) throws Throwable;
    private org.junit.runners.model.Statement methodCompletesWithParameters(org.junit.runners.model.FrameworkMethod, internal.Assignments, Object);
    protected void handleAssumptionViolation(org.junit.internal.AssumptionViolatedException);
    protected transient void reportParameterizedError(Throwable, Object[]) throws Throwable;
    private boolean nullsOk();
    protected void handleDataPointSuccess();
}
org/junit/experimental/theories/Theory.class
package org.junit.experimental.theories;
public abstract interface Theory extends annotation.Annotation {
    public abstract boolean nullsAccepted();
}
org/junit/experimental/theories/PotentialAssignment$1.class
package org.junit.experimental.theories;
synchronized class PotentialAssignment$1 extends PotentialAssignment {
    void PotentialAssignment$1(Object, String);
    public Object getValue();
    public String toString();
    public String getDescription();
}
org/junit/experimental/theories/Theories$TheoryAnchor$1$1.class
package org.junit.experimental.theories;
synchronized class Theories$TheoryAnchor$1$1 extends org.junit.runners.model.Statement {
    void Theories$TheoryAnchor$1$1(Theories$TheoryAnchor$1, org.junit.runners.model.Statement) throws Throwable;
    public void evaluate() throws Throwable;
}
org/junit/experimental/theories/FromDataPoints.class
package org.junit.experimental.theories;
public abstract interface FromDataPoints extends annotation.Annotation {
    public abstract String value();
}
org/junit/experimental/theories/DataPoints.class
package org.junit.experimental.theories;
public abstract interface DataPoints extends annotation.Annotation {
    public abstract String[] value();
    public abstract Class[] ignoredExceptions();
}
org/junit/experimental/theories/suppliers/TestedOnSupplier.class
package org.junit.experimental.theories.suppliers;
public synchronized class TestedOnSupplier extends org.junit.experimental.theories.ParameterSupplier {
    public void TestedOnSupplier();
    public java.util.List getValueSources(org.junit.experimental.theories.ParameterSignature);
}
org/junit/experimental/theories/suppliers/TestedOn.class
package org.junit.experimental.theories.suppliers;
public abstract interface TestedOn extends annotation.Annotation {
    public abstract int[] ints();
}
org/junit/experimental/theories/Theories$TheoryAnchor$1.class
package org.junit.experimental.theories;
synchronized class Theories$TheoryAnchor$1 extends org.junit.runners.BlockJUnit4ClassRunner {
    void Theories$TheoryAnchor$1(Theories$TheoryAnchor, Class, internal.Assignments) throws Throwable;
    protected void collectInitializationErrors(java.util.List);
    public org.junit.runners.model.Statement methodBlock(org.junit.runners.model.FrameworkMethod);
    protected org.junit.runners.model.Statement methodInvoker(org.junit.runners.model.FrameworkMethod, Object);
    public Object createTest() throws Exception;
}
org/junit/experimental/theories/PotentialAssignment.class
package org.junit.experimental.theories;
public abstract synchronized class PotentialAssignment {
    public void PotentialAssignment();
    public static PotentialAssignment forValue(String, Object);
    public abstract Object getValue() throws PotentialAssignment$CouldNotGenerateValueException;
    public abstract String getDescription() throws PotentialAssignment$CouldNotGenerateValueException;
}
org/junit/experimental/theories/ParametersSuppliedBy.class
package org.junit.experimental.theories;
public abstract interface ParametersSuppliedBy extends annotation.Annotation {
    public abstract Class value();
}
org/junit/experimental/theories/Theories.class
package org.junit.experimental.theories;
public synchronized class Theories extends org.junit.runners.BlockJUnit4ClassRunner {
    public void Theories(Class) throws org.junit.runners.model.InitializationError;
    protected void collectInitializationErrors(java.util.List);
    private void validateDataPointFields(java.util.List);
    private void validateDataPointMethods(java.util.List);
    protected void validateConstructor(java.util.List);
    protected void validateTestMethods(java.util.List);
    private void validateParameterSupplier(Class, java.util.List);
    protected java.util.List computeTestMethods();
    public org.junit.runners.model.Statement methodBlock(org.junit.runners.model.FrameworkMethod);
}
org/junit/experimental/theories/DataPoint.class
package org.junit.experimental.theories;
public abstract interface DataPoint extends annotation.Annotation {
    public abstract String[] value();
    public abstract Class[] ignoredExceptions();
}
org/junit/experimental/theories/internal/AllMembersSupplier$MethodParameterValue.class
package org.junit.experimental.theories.internal;
synchronized class AllMembersSupplier$MethodParameterValue extends org.junit.experimental.theories.PotentialAssignment {
    private final org.junit.runners.model.FrameworkMethod method;
    private void AllMembersSupplier$MethodParameterValue(org.junit.runners.model.FrameworkMethod);
    public Object getValue() throws org.junit.experimental.theories.PotentialAssignment$CouldNotGenerateValueException;
    public String getDescription() throws org.junit.experimental.theories.PotentialAssignment$CouldNotGenerateValueException;
}
org/junit/experimental/theories/internal/AllMembersSupplier.class
package org.junit.experimental.theories.internal;
public synchronized class AllMembersSupplier extends org.junit.experimental.theories.ParameterSupplier {
    private final org.junit.runners.model.TestClass clazz;
    public void AllMembersSupplier(org.junit.runners.model.TestClass);
    public java.util.List getValueSources(org.junit.experimental.theories.ParameterSignature) throws Throwable;
    private void addMultiPointMethods(org.junit.experimental.theories.ParameterSignature, java.util.List) throws Throwable;
    private void addSinglePointMethods(org.junit.experimental.theories.ParameterSignature, java.util.List);
    private void addMultiPointFields(org.junit.experimental.theories.ParameterSignature, java.util.List);
    private void addSinglePointFields(org.junit.experimental.theories.ParameterSignature, java.util.List);
    private void addDataPointsValues(Class, org.junit.experimental.theories.ParameterSignature, String, java.util.List, Object);
    private void addArrayValues(org.junit.experimental.theories.ParameterSignature, String, java.util.List, Object);
    private void addIterableValues(org.junit.experimental.theories.ParameterSignature, String, java.util.List, Iterable);
    private Object getStaticFieldValue(reflect.Field);
    private static boolean isAssignableToAnyOf(Class[], Object);
    protected java.util.Collection getDataPointsMethods(org.junit.experimental.theories.ParameterSignature);
    protected java.util.Collection getSingleDataPointFields(org.junit.experimental.theories.ParameterSignature);
    protected java.util.Collection getDataPointsFields(org.junit.experimental.theories.ParameterSignature);
    protected java.util.Collection getSingleDataPointMethods(org.junit.experimental.theories.ParameterSignature);
}
org/junit/experimental/theories/internal/EnumSupplier.class
package org.junit.experimental.theories.internal;
public synchronized class EnumSupplier extends org.junit.experimental.theories.ParameterSupplier {
    private Class enumType;
    public void EnumSupplier(Class);
    public java.util.List getValueSources(org.junit.experimental.theories.ParameterSignature);
}
org/junit/experimental/theories/internal/Assignments.class
package org.junit.experimental.theories.internal;
public synchronized class Assignments {
    private final java.util.List assigned;

Questions are in attached file.

Answer To: Questions are in attached file.

Answer To This Question Is Available To Download

Related Questions & Answers

Submit New Assignment