Coding assignment, all details are in the github link and all starter files and code needed are...

Question

Coding assignment, all details are in the github link and all starter files and code needed are attached but can also be downloaded and accessed through the link. Link:https://github.com/CSE12-SP21-Assignments/cse12-sp21-pa3-Mazesimport java.util.ArrayList; /*  * Write your JUnit tests here  * Use the formatMaze() method to get nicer JUnit output  */ import org.junit.Test; import static org.junit.Assert.*; public class TestSolvers { 	/* Helper method to compare two mazes */ 	public void checkMaze(SearchWorklist wl, Maze startMaze, String[] expected) { 		Square s = MazeSolver.solve(startMaze, wl); 		if(expected == null) { assertNull(s); } 		else { 			ArrayList sp = startMaze.storePath(); 			String actualStr = formatMaze(startMaze.showSolution(sp)); 			String expectedStr = formatMaze(expected); 			assertEquals(expectedStr, actualStr); 		} 	}	 	/* Helper method to format String[] output as String */ 	public String formatMaze(String[] arr) { 		String result = ""; 		for (String s: arr) 			result += "
"+s; 		return (result+"
"); 	} 	/* Add your own Worklist tests below */ 	/* ************** HINT ********************  	 * Use the helper methods to create simple 	 * tests that are easier to debug.  	 */ 	 	@Test 	public void dummyTest() { 		assertEquals("TODO: Remove this dummy test after writing your own tests.", "This is a dummy test."); 	} 	 }   import java.util.ArrayList; import java.util.Stack; /*  * DO NOT MODIFY class other than implement the storePath method  * Class that implements a Maze for traversal  *  */ class Maze { 	public final Square start, finish; 	public final Square[][] contents; 	public final int rows, cols; 	public Maze(Square start, Square target, Square[][] contents) { 		this.start = start; 		this.finish = target; 		this.contents = contents; 		this.rows = this.contents.length; 		this.cols = this.contents[0].length; 	} 	/** 	 * Initializes Squares in a contents array such that the start and target 	 * fields hold references to the corresponding locations in the contents 	 * array. 	 * 	 * @param mazeSpec expected to have all strings with the same length, and to 	 *                 have length at least 1 The strings should contain only the 	 *                 following characters: 	 *                 - '_': means "empty space" 	 *                 - '#': means "wall" 	 *                 - 'F': means "finish", can only appear once across all 	 *                 strings 	 *                 - 'S': means "start", can only appear once across all 	 *                 strings 	 */ 	public Maze(String[] mazeSpec) { 		int rows = mazeSpec.length; 		int cols = mazeSpec[0].length(); 		Square[][] contents = new Square[rows][cols]; 		Square start = null, finish = null; 		for (int i = 0; i  visitedHere) { 		char[][] background = buildBackground(); 		for (Square curr : visitedHere) { 			background[curr.getRow()][curr.getCol()] = '*'; 		} 		background[this.finish.getRow()][this.finish.getCol()] = 'F'; 		background[this.start.getRow()][this.start.getCol()] = 'S'; 		String result[] = new String[this.rows]; 		int i = 0; 		for (char[] cs : background) { 			result[i] = new String(cs); 			i += 1; 		} 		return result; 	} 	/** 	 * Return the solution path as an ArrayList of square from start to finish 	 * 	 * @return 	 */ 	public ArrayList storePath() { 		/* Complete this method */ 		return null; 	} }   /* Class to implement a Maze solver */ public abstract class MazeSolver { 	 	public static Square solve(Maze maze, SearchWorklist wl) { 		/* Complete this method */ 		return null; 	} 	/* Add any helper methods you want */ }   /*  * Class to implement SearchWorklist as a Stack and a Queue.  * You can use any built-in Java collections for this class.  */ class StackWorklist implements SearchWorklist { 	 } class QueueWorklist implements SearchWorklist { } public interface SearchWorklist { 	void add(Square c); 	Square remove(); 	boolean isEmpty(); }

Rushendra · Accepted Answer

cse12-sp21-pa3-Mazes/.git/config
[core]
	symlinks = false
	repositoryformatversion = 0
	filemode = false
	logallrefupdates = true
[remote "origin"]
	url = https://github.com/CSE12-SP21-Assignments/cse12-sp21-pa3-Mazes
	fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
	remote = origin
	merge = refs/heads/master
cse12-sp21-pa3-Mazes/.git/FETCH_HEAD
a2e5f6b61d7de67803ce232b4046069630fbf4a2	not-for-merge	branch 'master' of https://github.com/CSE12-SP21-Assignments/cse12-sp21-pa3-Mazes
cse12-sp21-pa3-Mazes/.git/HEAD
ref: refs/heads/master
cse12-sp21-pa3-Mazes/.git/index
cse12-sp21-pa3-Mazes/.git/logs/HEAD
0000000000000000000000000000000000000000 a2e5f6b61d7de67803ce232b4046069630fbf4a2 gokul  1618908046 +0530	
cse12-sp21-pa3-Mazes/.git/logs/refs/heads/master
0000000000000000000000000000000000000000 a2e5f6b61d7de67803ce232b4046069630fbf4a2 gokul  1618908046 +0530	
cse12-sp21-pa3-Mazes/.git/logs/refs/remotes/origin/master
0000000000000000000000000000000000000000 a2e5f6b61d7de67803ce232b4046069630fbf4a2 gokul  1618908046 +0530	fetch: created
cse12-sp21-pa3-Mazes/.git/objects/pack/pack-754bf70a1a98cd68051b8ba33c6908f2c0f46d69.idx
cse12-sp21-pa3-Mazes/.git/objects/pack/pack-754bf70a1a98cd68051b8ba33c6908f2c0f46d69.pack
cse12-sp21-pa3-Mazes/.git/refs/heads/master
a2e5f6b61d7de67803ce232b4046069630fbf4a2
cse12-sp21-pa3-Mazes/.git/refs/remotes/origin/master
a2e5f6b61d7de67803ce232b4046069630fbf4a2
cse12-sp21-pa3-Mazes/.project
 
	 cse12-sp21-pa3-Mazes
	 
	 
	
	 
	
	 
	
cse12-sp21-pa3-Mazes/pa3-starter/.classpath
 
	 
	 
	 
	 
	 
cse12-sp21-pa3-Mazes/pa3-starter/.gitignore
/bin/
cse12-sp21-pa3-Mazes/pa3-starter/.project
 
	 pa3-starter
	 
	 
	
	 
		 
			 org.eclipse.jdt.core.javabuilder
			 
			
		
	
	 
		 org.eclipse.jdt.core.javanature
	
cse12-sp21-pa3-Mazes/pa3-starter/.settings/org.eclipse.jdt.core.prefs
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=14
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=14
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
org.eclipse.jdt.core.compiler.release=enabled
org.eclipse.jdt.core.compiler.source=14
cse12-sp21-pa3-Mazes/pa3-starter/bin/Maze.class
cse12-sp21-pa3-Mazes/pa3-starter/bin/MazeSolver.class
cse12-sp21-pa3-Mazes/pa3-starter/bin/QueueWorklist.class
cse12-sp21-pa3-Mazes/pa3-starter/bin/SearchWorklist.class
cse12-sp21-pa3-Mazes/pa3-starter/bin/Square.class
cse12-sp21-pa3-Mazes/pa3-starter/bin/StackWorklist.class
cse12-sp21-pa3-Mazes/pa3-starter/bin/TestSolvers.class
cse12-sp21-pa3-Mazes/pa3-starter/lib/hamcrest-core-1.3.jar
META-INF/MANIFEST.MF
Manifest-Version: 1.0
Ant-Version: Apache Ant 1.8.1
Created-By: 1.6.0_33-b03 (Sun Microsystems Inc.)
Implementation-Title: hamcrest-core
Implementation-Vendor: hamcrest.org
Implementation-Version: 1.3
Built-By: tom
Built-Date: 2012-07-09 19:49:34
LICENSE.txt
BSD License
Copyright (c) 2000-2006, www.hamcrest.org
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of
conditions and the following disclaimer. Redistributions in binary form must reproduce
the above copyright notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
Neither the name of Hamcrest nor the names of its contributors may be used to endorse
or promote products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
org/hamcrest/BaseDescription.class
package org.hamcrest;
public abstract synchronized class BaseDescription implements Description {
    public void BaseDescription();
    public Description appendText(String);
    public Description appendDescriptionOf(SelfDescribing);
    public Description appendValue(Object);
    private String descriptionOf(Object);
    public transient Description appendValueList(String, String, String, Object[]);
    public Description appendValueList(String, String, String, Iterable);
    private Description appendValueList(String, String, String, java.util.Iterator);
    public Description appendList(String, String, String, Iterable);
    private Description appendList(String, String, String, java.util.Iterator);
    protected void append(String);
    protected abstract void append(char);
    private void toJavaSyntax(String);
    private void toJavaSyntax(char);
}
org/hamcrest/BaseMatcher.class
package org.hamcrest;
public abstract synchronized class BaseMatcher implements Matcher {
    public void BaseMatcher();
    public final void _dont_implement_Matcher___instead_extend_BaseMatcher_();
    public void describeMismatch(Object, Description);
    public String toString();
}
org/hamcrest/Condition$1.class
package org.hamcrest;
synchronized class Condition$1 {
}
org/hamcrest/Condition$Matched.class
package org.hamcrest;
final synchronized class Condition$Matched extends Condition {
    private final Object theValue;
    private final Description mismatch;
    private void Condition$Matched(Object, Description);
    public boolean matching(Matcher, String);
    public Condition and(Condition$Step);
}
org/hamcrest/Condition$NotMatched.class
package org.hamcrest;
final synchronized class Condition$NotMatched extends Condition {
    private void Condition$NotMatched();
    public boolean matching(Matcher, String);
    public Condition and(Condition$Step);
}
org/hamcrest/Condition$Step.class
package org.hamcrest;
public abstract interface Condition$Step {
    public abstract Condition apply(Object, Description);
}
org/hamcrest/Condition.class
package org.hamcrest;
public abstract synchronized class Condition {
    public static final Condition$NotMatched NOT_MATCHED;
    private void Condition();
    public abstract boolean matching(Matcher, String);
    public abstract Condition and(Condition$Step);
    public final boolean matching(Matcher);
    public final Condition then(Condition$Step);
    public static Condition notMatched();
    public static Condition matched(Object, Description);
    static void ();
}
org/hamcrest/CoreMatchers.class
package org.hamcrest;
public synchronized class CoreMatchers {
    public void CoreMatchers();
    public static Matcher allOf(Iterable);
    public static transient Matcher allOf(Matcher[]);
    public static Matcher allOf(Matcher, Matcher);
    public static Matcher allOf(Matcher, Matcher, Matcher);
    public static Matcher allOf(Matcher, Matcher, Matcher, Matcher);
    public static Matcher allOf(Matcher, Matcher, Matcher, Matcher, Matcher);
    public static Matcher allOf(Matcher, Matcher, Matcher, Matcher, Matcher, Matcher);
    public static core.AnyOf anyOf(Iterable);
    public static core.AnyOf anyOf(Matcher, Matcher, Matcher);
    public static core.AnyOf anyOf(Matcher, Matcher, Matcher, Matcher);
    public static core.AnyOf anyOf(Matcher, Matcher, Matcher, Matcher, Matcher);
    public static core.AnyOf anyOf(Matcher, Matcher, Matcher, Matcher, Matcher, Matcher);
    public static core.AnyOf anyOf(Matcher, Matcher);
    public static transient core.AnyOf anyOf(Matcher[]);
    public static core.CombinableMatcher$CombinableBothMatcher both(Matcher);
    public static core.CombinableMatcher$CombinableEitherMatcher either(Matcher);
    public static transient Matcher describedAs(String, Matcher, Object[]);
    public static Matcher everyItem(Matcher);
    public static Matcher is(Object);
    public static Matcher is(Matcher);
    public static Matcher is(Class);
    public static Matcher isA(Class);
    public static Matcher anything();
    public static Matcher anything(String);
    public static Matcher hasItem(Object);
    public static Matcher hasItem(Matcher);
    public static transient Matcher hasItems(Object[]);
    public static transient Matcher hasItems(Matcher[]);
    public static Matcher equalTo(Object);
    public static Matcher any(Class);
    public static Matcher instanceOf(Class);
    public static Matcher not(Matcher);
    public static Matcher not(Object);
    public static Matcher nullValue();
    public static Matcher nullValue(Class);
    public static Matcher notNullValue();
    public static Matcher notNullValue(Class);
    public static Matcher sameInstance(Object);
    public static Matcher theInstance(Object);
    public static Matcher containsString(String);
    public static Matcher startsWith(String);
    public static Matcher endsWith(String);
}
org/hamcrest/CustomMatcher.class
package org.hamcrest;
public abstract synchronized class CustomMatcher extends BaseMatcher {
    private final String fixedDescription;
    public void CustomMatcher(String);
    public final void describeTo(Description);
}
org/hamcrest/CustomTypeSafeMatcher.class
package org.hamcrest;
public abstract synchronized class CustomTypeSafeMatcher extends TypeSafeMatcher {
    private final String fixedDescription;
    public void CustomTypeSafeMatcher(String);
    public final void describeTo(Description);
}
org/hamcrest/Description$NullDescription.class
package org.hamcrest;
public final synchronized class Description$NullDescription implements Description {
    public void Description$NullDescription();
    public Description appendDescriptionOf(SelfDescribing);
    public Description appendList(String, String, String, Iterable);
    public Description appendText(String);
    public Description appendValue(Object);
    public transient Description appendValueList(String, String, String, Object[]);
    public Description appendValueList(String, String, String, Iterable);
    public String toString();
}
org/hamcrest/Description.class
package org.hamcrest;
public abstract interface Description {
    public static final Description NONE;
    public abstract Description appendText(String);
    public abstract Description appendDescriptionOf(SelfDescribing);
    public abstract Description appendValue(Object);
    public abstract transient Description appendValueList(String, String, String, Object[]);
    public abstract Description appendValueList(String, String, String, Iterable);
    public abstract Description appendList(String, String, String, Iterable);
    static void ();
}
org/hamcrest/DiagnosingMatcher.class
package org.hamcrest;
public abstract synchronized class DiagnosingMatcher extends BaseMatcher {
    public void DiagnosingMatcher();
    public final boolean matches(Object);
    public final void describeMismatch(Object, Description);
    protected abstract boolean matches(Object, Description);
}
org/hamcrest/Factory.class
package org.hamcrest;
public abstract interface Factory extends annotation.Annotation {
}
org/hamcrest/FeatureMatcher.class
package org.hamcrest;
public abstract synchronized class FeatureMatcher extends TypeSafeDiagnosingMatcher {
    private static final internal.ReflectiveTypeFinder TYPE_FINDER;
    private final Matcher subMatcher;
    private final String featureDescription;
    private final String featureName;
    public void FeatureMatcher(Matcher, String, String);
    protected abstract Object featureValueOf(Object);
    protected boolean matchesSafely(Object, Description);
    public final void describeTo(Description);
    static void ();
}
org/hamcrest/Matcher.class
package org.hamcrest;
public abstract interface Matcher extends SelfDescribing {
    public abstract boolean matches(Object);
    public abstract void describeMismatch(Object, Description);
    public abstract void _dont_implement_Matcher___instead_extend_BaseMatcher_();
}
org/hamcrest/MatcherAssert.class
package org.hamcrest;
public synchronized class MatcherAssert {
    public void MatcherAssert();
    public static void assertThat(Object, Matcher);
    public static void assertThat(String, Object, Matcher);
    public static void assertThat(String, boolean);
}
org/hamcrest/SelfDescribing.class
package org.hamcrest;
public abstract interface SelfDescribing {
    public abstract void describeTo(Description);
}
org/hamcrest/StringDescription.class
package org.hamcrest;
public synchronized class StringDescription extends BaseDescription {
    private final Appendable out;
    public void StringDescription();
    public void StringDescription(Appendable);
    public static String toString(SelfDescribing);
    public static String asString(SelfDescribing);
    protected void append(String);
    protected void append(char);
    public String toString();
}
org/hamcrest/TypeSafeDiagnosingMatcher.class
package org.hamcrest;
public abstract synchronized class TypeSafeDiagnosingMatcher extends BaseMatcher {
    private static final internal.ReflectiveTypeFinder TYPE_FINDER;
    private final Class expectedType;
    protected abstract boolean matchesSafely(Object, Description);
    protected void TypeSafeDiagnosingMatcher(Class);
    protected void TypeSafeDiagnosingMatcher(internal.ReflectiveTypeFinder);
    protected void TypeSafeDiagnosingMatcher();
    public final boolean matches(Object);
    public final void describeMismatch(Object, Description);
    static void ();
}
org/hamcrest/TypeSafeMatcher.class
package org.hamcrest;
public abstract synchronized class TypeSafeMatcher extends BaseMatcher {
    private static final internal.ReflectiveTypeFinder TYPE_FINDER;
    private final Class expectedType;
    protected void TypeSafeMatcher();
    protected void TypeSafeMatcher(Class);
    protected void TypeSafeMatcher(internal.ReflectiveTypeFinder);
    protected abstract boolean matchesSafely(Object);
    protected void describeMismatchSafely(Object, Description);
    public final boolean matches(Object);
    public final void describeMismatch(Object, Description);
    static void ();
}
org/hamcrest/core/AllOf.class
package org.hamcrest.core;
public synchronized class AllOf extends org.hamcrest.DiagnosingMatcher {
    private final Iterable matchers;
    public void AllOf(Iterable);
    public boolean matches(Object, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher allOf(Iterable);
    public static transient org.hamcrest.Matcher allOf(org.hamcrest.Matcher[]);
    public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static org.hamcrest.Matcher allOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
}
org/hamcrest/core/AnyOf.class
package org.hamcrest.core;
public synchronized class AnyOf extends ShortcutCombination {
    public void AnyOf(Iterable);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public static AnyOf anyOf(Iterable);
    public static transient AnyOf anyOf(org.hamcrest.Matcher[]);
    public static AnyOf anyOf(org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static AnyOf anyOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static AnyOf anyOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static AnyOf anyOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
    public static AnyOf anyOf(org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher, org.hamcrest.Matcher);
}
org/hamcrest/core/CombinableMatcher$CombinableBothMatcher.class
package org.hamcrest.core;
public final synchronized class CombinableMatcher$CombinableBothMatcher {
    private final org.hamcrest.Matcher first;
    public void CombinableMatcher$CombinableBothMatcher(org.hamcrest.Matcher);
    public CombinableMatcher and(org.hamcrest.Matcher);
}
org/hamcrest/core/CombinableMatcher$CombinableEitherMatcher.class
package org.hamcrest.core;
public final synchronized class CombinableMatcher$CombinableEitherMatcher {
    private final org.hamcrest.Matcher first;
    public void CombinableMatcher$CombinableEitherMatcher(org.hamcrest.Matcher);
    public CombinableMatcher or(org.hamcrest.Matcher);
}
org/hamcrest/core/CombinableMatcher.class
package org.hamcrest.core;
public synchronized class CombinableMatcher extends org.hamcrest.TypeSafeDiagnosingMatcher {
    private final org.hamcrest.Matcher matcher;
    public void CombinableMatcher(org.hamcrest.Matcher);
    protected boolean matchesSafely(Object, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    public CombinableMatcher and(org.hamcrest.Matcher);
    public CombinableMatcher or(org.hamcrest.Matcher);
    private java.util.ArrayList templatedListWith(org.hamcrest.Matcher);
    public static CombinableMatcher$CombinableBothMatcher both(org.hamcrest.Matcher);
    public static CombinableMatcher$CombinableEitherMatcher either(org.hamcrest.Matcher);
}
org/hamcrest/core/DescribedAs.class
package org.hamcrest.core;
public synchronized class DescribedAs extends org.hamcrest.BaseMatcher {
    private final String descriptionTemplate;
    private final org.hamcrest.Matcher matcher;
    private final Object[] values;
    private static final java.util.regex.Pattern ARG_PATTERN;
    public void DescribedAs(String, org.hamcrest.Matcher, Object[]);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public void describeMismatch(Object, org.hamcrest.Description);
    public static transient org.hamcrest.Matcher describedAs(String, org.hamcrest.Matcher, Object[]);
    static void ();
}
org/hamcrest/core/Every.class
package org.hamcrest.core;
public synchronized class Every extends org.hamcrest.TypeSafeDiagnosingMatcher {
    private final org.hamcrest.Matcher matcher;
    public void Every(org.hamcrest.Matcher);
    public boolean matchesSafely(Iterable, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher everyItem(org.hamcrest.Matcher);
}
org/hamcrest/core/Is.class
package org.hamcrest.core;
public synchronized class Is extends org.hamcrest.BaseMatcher {
    private final org.hamcrest.Matcher matcher;
    public void Is(org.hamcrest.Matcher);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public void describeMismatch(Object, org.hamcrest.Description);
    public static org.hamcrest.Matcher is(org.hamcrest.Matcher);
    public static org.hamcrest.Matcher is(Object);
    public static org.hamcrest.Matcher is(Class);
    public static org.hamcrest.Matcher isA(Class);
}
org/hamcrest/core/IsAnything.class
package org.hamcrest.core;
public synchronized class IsAnything extends org.hamcrest.BaseMatcher {
    private final String message;
    public void IsAnything();
    public void IsAnything(String);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher anything();
    public static org.hamcrest.Matcher anything(String);
}
org/hamcrest/core/IsCollectionContaining.class
package org.hamcrest.core;
public synchronized class IsCollectionContaining extends org.hamcrest.TypeSafeDiagnosingMatcher {
    private final org.hamcrest.Matcher elementMatcher;
    public void IsCollectionContaining(org.hamcrest.Matcher);
    protected boolean matchesSafely(Iterable, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher hasItem(org.hamcrest.Matcher);
    public static org.hamcrest.Matcher hasItem(Object);
    public static transient org.hamcrest.Matcher hasItems(org.hamcrest.Matcher[]);
    public static transient org.hamcrest.Matcher hasItems(Object[]);
}
org/hamcrest/core/IsEqual.class
package org.hamcrest.core;
public synchronized class IsEqual extends org.hamcrest.BaseMatcher {
    private final Object expectedValue;
    public void IsEqual(Object);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    private static boolean areEqual(Object, Object);
    private static boolean areArraysEqual(Object, Object);
    private static boolean areArrayLengthsEqual(Object, Object);
    private static boolean areArrayElementsEqual(Object, Object);
    private static boolean isArray(Object);
    public static org.hamcrest.Matcher equalTo(Object);
}
org/hamcrest/core/IsInstanceOf.class
package org.hamcrest.core;
public synchronized class IsInstanceOf extends org.hamcrest.DiagnosingMatcher {
    private final Class expectedClass;
    private final Class matchableClass;
    public void IsInstanceOf(Class);
    private static Class matchableClass(Class);
    protected boolean matches(Object, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher instanceOf(Class);
    public static org.hamcrest.Matcher any(Class);
}
org/hamcrest/core/IsNot.class
package org.hamcrest.core;
public synchronized class IsNot extends org.hamcrest.BaseMatcher {
    private final org.hamcrest.Matcher matcher;
    public void IsNot(org.hamcrest.Matcher);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher not(org.hamcrest.Matcher);
    public static org.hamcrest.Matcher not(Object);
}
org/hamcrest/core/IsNull.class
package org.hamcrest.core;
public synchronized class IsNull extends org.hamcrest.BaseMatcher {
    public void IsNull();
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher nullValue();
    public static org.hamcrest.Matcher notNullValue();
    public static org.hamcrest.Matcher nullValue(Class);
    public static org.hamcrest.Matcher notNullValue(Class);
}
org/hamcrest/core/IsSame.class
package org.hamcrest.core;
public synchronized class IsSame extends org.hamcrest.BaseMatcher {
    private final Object object;
    public void IsSame(Object);
    public boolean matches(Object);
    public void describeTo(org.hamcrest.Description);
    public static org.hamcrest.Matcher sameInstance(Object);
    public static org.hamcrest.Matcher theInstance(Object);
}
org/hamcrest/core/ShortcutCombination.class
package org.hamcrest.core;
abstract synchronized class ShortcutCombination extends org.hamcrest.BaseMatcher {
    private final Iterable matchers;
    public void ShortcutCombination(Iterable);
    public abstract boolean matches(Object);
    public abstract void describeTo(org.hamcrest.Description);
    protected boolean matches(Object, boolean);
    public void describeTo(org.hamcrest.Description, String);
}
org/hamcrest/core/StringContains.class
package org.hamcrest.core;
public synchronized class StringContains extends SubstringMatcher {
    public void StringContains(String);
    protected boolean evalSubstringOf(String);
    protected String relationship();
    public static org.hamcrest.Matcher containsString(String);
}
org/hamcrest/core/StringEndsWith.class
package org.hamcrest.core;
public synchronized class StringEndsWith extends SubstringMatcher {
    public void StringEndsWith(String);
    protected boolean evalSubstringOf(String);
    protected String relationship();
    public static org.hamcrest.Matcher endsWith(String);
}
org/hamcrest/core/StringStartsWith.class
package org.hamcrest.core;
public synchronized class StringStartsWith extends SubstringMatcher {
    public void StringStartsWith(String);
    protected boolean evalSubstringOf(String);
    protected String relationship();
    public static org.hamcrest.Matcher startsWith(String);
}
org/hamcrest/core/SubstringMatcher.class
package org.hamcrest.core;
public abstract synchronized class SubstringMatcher extends org.hamcrest.TypeSafeMatcher {
    protected final String substring;
    protected void SubstringMatcher(String);
    public boolean matchesSafely(String);
    public void describeMismatchSafely(String, org.hamcrest.Description);
    public void describeTo(org.hamcrest.Description);
    protected abstract boolean evalSubstringOf(String);
    protected abstract String relationship();
}
org/hamcrest/internal/ArrayIterator.class
package org.hamcrest.internal;
public synchronized class ArrayIterator implements java.util.Iterator {
    private final Object array;
    private int currentIndex;
    public void ArrayIterator(Object);
    public boolean hasNext();
    public Object next();
    public void remove();
}
org/hamcrest/internal/ReflectiveTypeFinder.class
package org.hamcrest.internal;
public synchronized class ReflectiveTypeFinder {
    private final String methodName;
    private final int expectedNumberOfParameters;
    private final int typedParameter;
    public void ReflectiveTypeFinder(String, int, int);
    public Class findExpectedType(Class);
    protected boolean canObtainExpectedTypeFrom(reflect.Method);
    protected Class expectedTypeFrom(reflect.Method);
}
org/hamcrest/internal/SelfDescribingValue.class
package org.hamcrest.internal;
public synchronized class SelfDescribingValue implements org.hamcrest.SelfDescribing {
    private Object value;
    public void SelfDescribingValue(Object);
    public void describeTo(org.hamcrest.Description);
}
org/hamcrest/internal/SelfDescribingValueIterator.class
package org.hamcrest.internal;
public synchronized class SelfDescribingValueIterator implements java.util.Iterator {
    private java.util.Iterator values;
    public void SelfDescribingValueIterator(java.util.Iterator);
    public boolean hasNext();
    public org.hamcrest.SelfDescribing next();
    public void remove();
}
cse12-sp21-pa3-Mazes/pa3-starter/lib/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.

import java.util.ArrayList; /* * Write your JUnit tests here * Use the formatMaze() method to get nicer JUnit output / import org.junit.Test; import static org.junit.Assert.; public class...

Answer To: import java.util.ArrayList; /* * Write your JUnit tests here * Use the formatMaze() method to get...

Answer To This Question Is Available To Download

Related Questions & Answers

Submit New Assignment

import java.util.ArrayList; /* * Write your JUnit tests here * Use the formatMaze() method to get nicer JUnit output */ import org.junit.Test; import static org.junit.Assert.*; public class...

Answer To: import java.util.ArrayList; /* * Write your JUnit tests here * Use the formatMaze() method to get...

Answer To This Question Is Available To Download

Related Questions & Answers

Submit New Assignment

import java.util.ArrayList; /* * Write your JUnit tests here * Use the formatMaze() method to get nicer JUnit output / import org.junit.Test; import static org.junit.Assert.; public class...