TestCase (Student Library Documentation)

java.lang.Object
- junit.framework.Assert
- - junit.framework.TestCase
  - - student.TestCase

All Implemented Interfaces:

junit.framework.Test

Direct Known Subclasses:

GUITestCase
```
public class TestCase
extends junit.framework.TestCase
```
This class provides some customized behavior beyond the basics of TestCase to support testing of I/O driven programs and flexible/fuzzy comparison of strings. In most cases, it can be used as a completely transparent drop-in replacement for its parent class.
Fuzzy string comparisons in this class default to standard rules in StringNormalizer (excluding the OPT_* rules). You can use the stringNormalizer() method to access the normalizer and set your own comparison options, however.

Version:

$Revision: 1.20 $, $Date: 2015/08/23 22:28:09 $

Author:

Stephen Edwards, Last changed by $Author: stedwar2 $

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`TestCase.AssertMethodCalledIncorrectly` A custom error class that represents a mistake in calling the wrong assert method for a given situation.

Constructor Summary

Constructors
Constructor and Description

TestCase()
Creates a new TestCase object.

TestCase(String name)
Creates a new TestCase object.

Constructors
Constructor and Description
`TestCase()` Creates a new TestCase object.
`TestCase(String name)` Creates a new TestCase object.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`assertEquals(Number expected, Number actual)` There is no assertion to compare ints with floats or doubles, or to compare two floats or two doubles without specifying a tolerance, but autoboxing will allow you to compare them as objects, which is never desired.
`static void`	`assertEquals(String message, Number expected, Number actual)` There is no assertion to compare ints with floats or doubles, or to compare two floats or two doubles without specifying a tolerance, but autoboxing will allow you to compare them as objects, which is never desired.
`static void`	`assertEquals(String expected, String actual)` Asserts that two Strings are equal.
`static void`	`assertEquals(String message, String expected, String actual)` Asserts that two Strings are equal.
`static void`	`assertFalse(boolean condition)` Asserts that a condition is false.
`static void`	`assertFalse(String message, boolean condition)` Asserts that a condition is false.
`static void`	`assertFuzzyEquals(String expected, String actual)` Asserts that two Strings are equal, respecting preferences for what differences matter.
`static void`	`assertFuzzyEquals(String message, String expected, String actual)` Asserts that two Strings are equal, respecting preferences for what differences matter.
`static void`	`assertSame(Number expected, Number actual)` There is no assertion to compare primitive values using assertSame(), but autoboxing will allow you to compare them as objects, which is never desired.
`static void`	`assertSame(String message, Number expected, Number actual)` There is no assertion to compare primitive values using assertSame(), but autoboxing will allow you to compare them as objects, which is never desired.
`static void`	`assertTrue(boolean condition)` Asserts that a condition is true.
`static void`	`assertTrue(String message, boolean condition)` Asserts that a condition is true.
`static String`	`compact(String content)` Takes a string and, if it is too long, shortens it by replacing the middle with an ellipsis.
`static String`	`compact(String content, int threshold, int prefixLen)` Takes a string and, if it is too long, shortens it by replacing the middle with an ellipsis.
`boolean`	`contains(String largerString, String... substrings)` Determine whether one String contains a sequence of other substrings in order.
`boolean`	`containsRegex(String largerString, Pattern... substrings)` Determine whether one String contains a sequence of other substrings in order, where the expected substrings are specified as a regular expressions.
`boolean`	`containsRegex(String largerString, String... substrings)` Determine whether one String contains a sequence of other substrings in order, where the expected substrings are specified as a regular expressions.
`boolean`	`equals(String left, String right)` Determines whether two Strings are equal.
`boolean`	`equalsRegex(String actual, Pattern expected)` Determines whether a String exactly matches an expected regular expression.
`boolean`	`equalsRegex(String actual, String expected)` Determines whether a String exactly matches an expected regular expression.
`String`	`fromFile(File file)` Load the contents of a text file and return it as a string (normalizing newlines to unix-style line ending conventions).
`String`	`fromFile(String file)` Load the contents of a text file and return it as a string (normalizing newlines to unix-style line ending conventions).
`boolean`	`fuzzyContains(String largerString, String... substrings)` Determine whether one String contains a sequence of other substrings in order, respecting preferences for what differences matter.
`boolean`	`fuzzyContainsRegex(String largerString, Pattern... substrings)` Determine whether one String contains a sequence of other substrings in order, where the expected substrings are specified as regular expressions, and respecting preferences for what differences matter.
`boolean`	`fuzzyContainsRegex(String largerString, String... substrings)` Determine whether one String contains a sequence of other substrings in order, where the expected substrings are specified as regular expressions, and respecting preferences for what differences matter.
`boolean`	`fuzzyEquals(String left, String right)` Determines whether two Strings are equal, respecting preferences for what differences matter.
`boolean`	`fuzzyEqualsRegex(String actual, Pattern expected)` Determines whether a String exactly matches an expected regular expression, respecting preferences for what differences matter.
`boolean`	`fuzzyEqualsRegex(String actual, String expected)` Determines whether a String exactly matches an expected regular expression, respecting preferences for what differences matter.
`Scanner`	`in()` Get an input stream containing the contents that you specify.
`static void`	`installExitHandler()` This method is for internal use only and should not be called by other code.
`protected void`	`instrumentIO()` An internal helper that ensures input/output buffering is in place before each test case.
`String`	`multiline(String... lines)` Combine a list of strings provided as arguments into a single string, following each "line" with a line terminator.
`PrintWriterWithHistory`	`out()` Get an output stream suitable for use in test cases.
`void`	`prepareIO()` Resets IO and output reasons, then instruments IO for next method.
`protected void`	`resetIO()` An internal helper that resets all of the input/output buffering after each test case.
`static void`	`resetSystemIO()` An internal helper that resets the system part of the input/output buffering after each test case.
`void`	`setIn(Scanner contents)` Set the contents of this test case's input stream, which can then be retrieved using `in()`.
`void`	`setIn(String... contents)` Set the contents of this test case's input stream, which can then be retrieved using `in()`.
`static void`	`setNormalizeLineEndings(boolean value)` Control whether strings manipulated in this test case will have their line terminator sequences automatically normalized to unix-style line terminators (default is true).
`void`	`setSystemIn(String... contents)` Set the contents of `System.in` for this test case.
`protected void`	`setUp()` Sets up the fixture, for example, open a network connection.
`static void`	`setUseFuzzyStringComparisons(boolean value)` Control whether assertEquals() on strings will use fuzzy comparisons (using the `stringNormalizer()` to ignore things like punctuation differences, capitalization differences, etc.--see the StringNormalizer documentation for how to control what differences are ignored).
`protected static StringNormalizer`	`stringNormalizer()` Access the string normalizer that this test case uses in fuzzy string comparisons.
`PrintStreamWithHistory`	`systemErr()` Get a version of `System.err` that records its history so you can compare against it later.
`PrintStreamWithHistory`	`systemOut()` Get a version of `System.out` that records its history so you can compare against it later.
`protected void`	`tearDown()` Tears down the fixture, for example, close a network connection.
`static void`	`uninstallExitHandler()` This method is for internal use only and should not be called by other code.

Methods inherited from class junit.framework.TestCase
assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertNotNull, assertNotNull, assertNotSame, assertNotSame, assertNull, assertNull, assertSame, assertSame, countTestCases, createResult, fail, fail, failNotEquals, failNotSame, failSame, format, getName, run, run, runBare, runTest, setName, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - TestCase
```
public TestCase()
```
    Creates a new TestCase object.
  - TestCase
```
public TestCase(String name)
```
    Creates a new TestCase object.
    
    Parameters:
    
    name - The name of this test case
- Method Detail
  - setUp
```
protected void setUp()
              throws Exception
```
    Sets up the fixture, for example, open a network connection. This method is called before each test in this class is executed.
    
    Overrides:
    
    setUp in class junit.framework.TestCase
    
    Throws:
    
    Exception
  - tearDown
```
protected void tearDown()
                 throws Exception
```
    Tears down the fixture, for example, close a network connection. This method is called after each test in this class is executed.
    
    Overrides:
    
    tearDown in class junit.framework.TestCase
    
    Throws:
    
    Exception
  - instrumentIO
```
protected void instrumentIO()
```
    An internal helper that ensures input/output buffering is in place before each test case.
  - resetIO
```
protected void resetIO()
```
    An internal helper that resets all of the input/output buffering after each test case.
  - out
```
public PrintWriterWithHistory out()
```
    Get an output stream suitable for use in test cases. You can pass this output stream to your own methods, and later call its PrintWriterWithHistory.getHistory() method to extract all the output in the form of a string. The contents of this stream get cleared for every test case.
    
    Returns:
    
    a PrintWriter suitable for use in test cases
  - systemOut
```
public PrintStreamWithHistory systemOut()
```
    Get a version of System.out that records its history so you can compare against it later. The history of this stream gets cleared for every test case.
    
    Returns:
    
    a PrintStream connected to System.out that is suitable for use in test cases
  - systemErr
```
public PrintStreamWithHistory systemErr()
```
    Get a version of System.err that records its history so you can compare against it later. The history of this stream gets cleared for every test case.
    
    Returns:
    
    a PrintStream connected to System.err that is suitable for use in test cases
  - in
```
public Scanner in()
```
    Get an input stream containing the contents that you specify. Set the contents by calling setIn(String...) or setIn(Scanner) to set the contents before you begin using this stream. This stream gets reset for every test case.
    
    Returns:
    
    a Scanner containing any contents you have specified.
  - setIn
```
public void setIn(String... contents)
```
    Set the contents of this test case's input stream, which can then be retrieved using in().
    
    Parameters:
    
    contents - The contents to use for the stream, which replace any that were there before. The contents can be provided as a single string, or as a series of strings that should be merged using multiline(String...). Line terminator sequences in the contents will be normalized to unix-style line endings.
  - setIn
```
public void setIn(Scanner contents)
```
    Set the contents of this test case's input stream, which can then be retrieved using in().
    
    Parameters:
    
    contents - The contents to use for the stream, which replace any that were there before.
  - setSystemIn
```
public void setSystemIn(String... contents)
```
    Set the contents of System.in for this test case.
    
    Parameters:
    
    contents - The contents to use for the stream, which replace any that were there before. The contents can be provided as a single string, or as a series of strings that should be merged using multiline(String...). Line terminator sequences in the contents will be normalized to unix-style line endings.
  - multiline
```
public String multiline(String... lines)
```
    Combine a list of strings provided as arguments into a single string, following each "line" with a line terminator. This gives the same effect as if println() were called on each argument, collecting the results into a single string. Note that line terminators will be normalized to unix-style line terminators, if desired.
    
    Parameters:
    
    lines - The series of lines to be combined (a line terminator will be added after each one).
    
    Returns:
    
    A single string representing the concatenation of all the provided lines.
  - fromFile
```
public String fromFile(File file)
```
    Load the contents of a text file and return it as a string (normalizing newlines to unix-style line ending conventions).
    
    Parameters:
    
    file - The file to read from.
    
    Returns:
    
    The contents of the specified file, as a single string.
  - fromFile
```
public String fromFile(String file)
```
    Load the contents of a text file and return it as a string (normalizing newlines to unix-style line ending conventions).
    
    Parameters:
    
    file - The name of the file to read from.
    
    Returns:
    
    The contents of the specified file, as a single string.
  - stringNormalizer
```
protected static StringNormalizer stringNormalizer()
```
    Access the string normalizer that this test case uses in fuzzy string comparisons. You can set your preferences for fuzzy string comparisons using this object's methods. These settings are persistent from test case method to test case method, so it is sufficient to set them in your test class constructor if you want to use the same settings for all of your test case methods.
    
    Returns:
    
    the string normalizer
    
    See Also:
    
    assertFuzzyEquals(String, String), StringNormalizer, StringNormalizer.addStandardRules()
  - setNormalizeLineEndings
```
public static void setNormalizeLineEndings(boolean value)
```
    Control whether strings manipulated in this test case will have their line terminator sequences automatically normalized to unix-style line terminators (default is true).
    
    Parameters:
    
    value - True if line endings should be automatically converted to unix-style, or false if they should be left alone.
  - setUseFuzzyStringComparisons
```
public static void setUseFuzzyStringComparisons(boolean value)
```
    Control whether assertEquals() on strings will use fuzzy comparisons (using the stringNormalizer() to ignore things like punctuation differences, capitalization differences, etc.--see the StringNormalizer documentation for how to control what differences are ignored). The default is false, meaning that fuzzy comparisons must be explicitly requested using one of the "fuzzy"-named methods. Calling this method with the parameter true will cause conventional assertEquals() calls to use fuzzy string normalization in comparisons as well, making assertEquals() and similar methods behave the same as assertFuzzyEquals().
    
    Parameters:
    
    value - True if string comparisons should be fuzzy in assertEquals().
  - assertFuzzyEquals
```
public static void assertFuzzyEquals(String expected,
                                     String actual)
```
    Asserts that two Strings are equal, respecting preferences for what differences matter. This method mirrors the static TestCase.assertEquals(String,String) method, augmenting its behavior with the ability to make "fuzzy" string comparisons that ignore things like differences in spacing, punctuation, or capitalization. Use stringNormalizer() to access and modify the StringNormalizer object's preferences for comparing strings.
    
    Parameters:
    
    expected - The expected value
    
    actual - The value to test
  - assertFuzzyEquals
```
public static void assertFuzzyEquals(String message,
                                     String expected,
                                     String actual)
```
    Asserts that two Strings are equal, respecting preferences for what differences matter. This method mirrors the static TestCase.assertEquals(String,String) method, augmenting its behavior with the ability to make "fuzzy" string comparisons that ignore things like differences in spacing, punctuation, or capitalization. Use stringNormalizer() to access and modify the StringNormalizer object's preferences for comparing strings.
    
    Parameters:
    
    message - The message to use for a failed assertion
    
    expected - The expected value
    
    actual - The value to test
  - assertTrue
```
public static void assertTrue(String message,
                              boolean condition)
```
    Asserts that a condition is true. If it isn't, it throws an AssertionFailedError with the given message. This is a special version of TestCase.assertTrue(String,boolean) that issues special diagnostics when the assertion fails, if the given condition supports it.
    
    Parameters:
    
    message - The message to use for a failed assertion
    
    condition - The condition to check
  - assertTrue
```
public static void assertTrue(boolean condition)
```
    Asserts that a condition is true. If it isn't, it throws an AssertionFailedError with the given message. This is a special version of TestCase.assertTrue(boolean) that issues special diagnostics when the assertion fails, if the given condition supports it.
    
    Parameters:
    
    condition - The condition to check
  - assertFalse
```
public static void assertFalse(String message,
                               boolean condition)
```
    Asserts that a condition is false. If it isn't, it throws an AssertionFailedError with the given message. This is a special version of TestCase.assertFalse(String,boolean) that issues special diagnostics when the assertion fails, if the given condition supports it.
    
    Parameters:
    
    message - The message to use for a failed assertion
    
    condition - The condition to check
  - assertFalse
```
public static void assertFalse(boolean condition)
```
    Asserts that a condition is false. If it isn't, it throws an AssertionFailedError with the given message. This is a special version of TestCase.assertFalse(boolean) that issues special diagnostics when the assertion fails, if the given condition supports it.
    
    Parameters:
    
    condition - The condition to check
  - assertSame
```
public static void assertSame(String message,
                              Number expected,
                              Number actual)
```
    There is no assertion to compare primitive values using assertSame(), but autoboxing will allow you to compare them as objects, which is never desired. This overloaded method flags the problem as a test case failure rather than letting it go undiagnosed.
    
    Parameters:
    
    message - The message to use if the assertion fails
    
    expected - The expected value
    
    actual - The actual value
  - assertSame
```
public static void assertSame(Number expected,
                              Number actual)
```
    There is no assertion to compare primitive values using assertSame(), but autoboxing will allow you to compare them as objects, which is never desired. This overloaded method flags the problem as a test case failure rather than letting it go undiagnosed.
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - assertEquals
```
public static void assertEquals(String message,
                                Number expected,
                                Number actual)
```
    There is no assertion to compare ints with floats or doubles, or to compare two floats or two doubles without specifying a tolerance, but autoboxing will allow you to compare them as objects, which is never desired. This overloaded method flags the problem as a test case failure rather than letting it go undiagnosed.
    
    Parameters:
    
    message - The message to use if the assertion fails
    
    expected - The expected value
    
    actual - The actual value
  - assertEquals
```
public static void assertEquals(Number expected,
                                Number actual)
```
    There is no assertion to compare ints with floats or doubles, or to compare two floats or two doubles without specifying a tolerance, but autoboxing will allow you to compare them as objects, which is never desired. This overloaded method flags the problem as a test case failure rather than letting it go undiagnosed.
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - assertEquals
```
public static void assertEquals(String message,
                                String expected,
                                String actual)
```
    Asserts that two Strings are equal.
    
    Parameters:
    
    message - The message to use if the assertion fails
    
    expected - The expected value
    
    actual - The actual value
  - assertEquals
```
public static void assertEquals(String expected,
                                String actual)
```
    Asserts that two Strings are equal.
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - compact
```
public static String compact(String content,
                             int threshold,
                             int prefixLen)
```
    Takes a string and, if it is too long, shortens it by replacing the middle with an ellipsis. For example, calling compact("hello there", 6, 3) will return "hel...ere".
    
    Parameters:
    
    content - The string to shorten
    
    threshold - Strings longer than this will be compacted, while strings less than or equal to this limit will be returned unchanged
    
    prefixLen - How many characters at the front and back of the string to keep. This number must be less than or equal to half the threshold
    
    Returns:
    
    The shortened version of the string
  - compact
```
public static String compact(String content)
```
    Takes a string and, if it is too long, shortens it by replacing the middle with an ellipsis.
    
    Parameters:
    
    content - The string to shorten
    
    Returns:
    
    The shortened version of the string
  - equals
```
public boolean equals(String left,
                      String right)
```
    Determines whether two Strings are equal. This method is identical to String.equals(Object), but is provided for symmetry with the other comparison predicates provided in this class. For assertion writing, remember that TestCase.assertEquals(String,String) will produce more useful information on failure, however.
    
    Parameters:
    
    left - The first string to compare
    
    right - The second string to compare
    
    Returns:
    
    True if the strings are equal
  - fuzzyEquals
```
public boolean fuzzyEquals(String left,
                           String right)
```
    Determines whether two Strings are equal, respecting preferences for what differences matter. This method mirrors equals(String,String), augmenting its behavior with the ability to make "fuzzy" string comparisons that ignore things like differences in spacing, punctuation, or capitalization. It is also identical to assertFuzzyEquals(String,String), except that it returns the boolean result of the comparison instead of making a test case assertion. Use stringNormalizer() to access and modify the StringNormalizer object's preferences for comparing strings. For assertion writing, remember that assertFuzzyEquals(String,String) will produce more useful information on failure, however.
    
    Parameters:
    
    left - The first string to compare
    
    right - The second string to compare
    
    Returns:
    
    True if the strings are equal
  - equalsRegex
```
public boolean equalsRegex(String actual,
                           String expected)
```
    Determines whether a String exactly matches an expected regular expression. A null for the actual value is treated the same as an empty string for the purposes of matching. The regular expression must match the full string (all characters taken together). To match a substring, use containsRegex(String,String...) instead.
    Note that this predicate uses the opposite parameter ordering from JUnit assertions: The value to test is the first parameter, and the expected pattern is the second.
    
    Parameters:
    
    actual - The value to test
    
    expected - The expected value (interpreted as a regular expression Pattern)
    
    Returns:
    
    True if the actual matches the expected pattern
  - equalsRegex
```
public boolean equalsRegex(String actual,
                           Pattern expected)
```
    Determines whether a String exactly matches an expected regular expression. A null for the actual value is treated the same as an empty string for the purposes of matching. The regular expression must match the full string (all characters taken together). To match a substring, use containsRegex(String,Pattern...) instead.
    Note that this predicate uses the opposite parameter ordering from JUnit assertions: The value to test is the first parameter, and the expected pattern is the second.
    
    Parameters:
    
    actual - The value to test
    
    expected - The expected value
    
    Returns:
    
    True if the actual matches the expected pattern
  - fuzzyEqualsRegex
```
public boolean fuzzyEqualsRegex(String actual,
                                String expected)
```
    Determines whether a String exactly matches an expected regular expression, respecting preferences for what differences matter. A null for the actual value is treated the same as an empty string for the purposes of matching. The regular expression must match the full string (all characters taken together). To match a substring, use fuzzyContainsRegex(String,String...) instead.
    Note that this predicate uses the opposite parameter ordering from JUnit assertions: The value to test is the first parameter, and the expected pattern is the second.
    
    Use stringNormalizer() to access and modify the StringNormalizer object's preferences for comparing strings.
    
    Parameters:
    
    actual - The value to test
    
    expected - The expected value (interpreted as a regular expression Pattern)
    
    Returns:
    
    True if the actual matches the expected pattern
  - fuzzyEqualsRegex
```
public boolean fuzzyEqualsRegex(String actual,
                                Pattern expected)
```
    Determines whether a String exactly matches an expected regular expression, respecting preferences for what differences matter. A null for the actual value is treated the same as an empty string for the purposes of matching. The regular expression must match the full string (all characters taken together). To match a substring, use fuzzyContainsRegex(String,String...) instead.
    Use stringNormalizer() to access and modify the StringNormalizer object's preferences for comparing strings.
    
    Parameters:
    
    actual - The value to test
    
    expected - The expected value
    
    Returns:
    
    True if the actual matches the expected pattern
  - contains
```
public boolean contains(String largerString,
                        String... substrings)
```
    Determine whether one String contains a sequence of other substrings in order. In addition to the string to search, you can provide an arbitrary number of additional parameters to search for. If you only provide one substring, this method behaves the same as String.contains(CharSequence). If you provide more than one substring, it looks for each such element in turn in the larger string, making sure they are all found in the proper order (each substring must strictly follow the previous one, although there can be any amount of intervening characters between any two substrings in the array). If the larger string is null, this method returns false (since it can contain nothing).
    Note that this predicate uses the opposite parameter ordering from JUnit assertions: The value to test is the first parameter, and the expected substrings are the second.
    
    Parameters:
    
    largerString - The target to look in
    
    substrings - One or more substrings to look for (in order)
    
    Returns:
    
    True if the largerString contains all of the specified substrings in order.
  - fuzzyContains
```
public boolean fuzzyContains(String largerString,
                             String... substrings)
```
    Determine whether one String contains a sequence of other substrings in order, respecting preferences for what differences matter. It looks for each of the specified substrings in turn in the larger string, making sure they are all found in the proper order (each substring must strictly follow the previous one, although there can be any amount of intervening characters between any two substrings in the array). If the larger string is null, this method returns false (since it can contain nothing).
    This method makes "fuzzy" string comparisons that ignore things like differences in spacing, punctuation, or capitalization. Use stringNormalizer() to access and modify the StringNormalizer object's preferences for comparing strings.
    
    Note that this predicate uses the opposite parameter ordering from JUnit assertions: The value to test is the first parameter, and the expected substrings are the second.
    
    Parameters:
    
    largerString - The target to look in
    
    substrings - The substrings to look for (in order)
    
    Returns:
    
    True if the largerString contains all of the specified substrings in order.
  - containsRegex
```
public boolean containsRegex(String largerString,
                             String... substrings)
```
    Determine whether one String contains a sequence of other substrings in order, where the expected substrings are specified as a regular expressions. It looks for each of the specified regular expressions in turn in the larger string, making sure they are all found in the proper order (each substring must strictly follow the previous one, although there can be any amount of intervening characters between any two substrings in the array). If the larger string is null, this method returns false (since it can contain nothing).
    Note that this predicate uses the opposite parameter ordering from JUnit assertions: The value to test is the first parameter, and the expected substrings are the second.
    
    Parameters:
    
    largerString - The target to look in
    
    substrings - A sequence of expected substrings (interpreted as regular expression Patterns), which must occur in the same order in the larger string
    
    Returns:
    
    True if the largerString contains all of the specified regular expressions in order.
  - containsRegex
```
public boolean containsRegex(String largerString,
                             Pattern... substrings)
```
    Determine whether one String contains a sequence of other substrings in order, where the expected substrings are specified as a regular expressions. It looks for each of the specified regular expressions in turn in the larger string, making sure they are all found in the proper order (each substring must strictly follow the previous one, although there can be any amount of intervening characters between any two substrings in the array). If the larger string is null, this method returns false (since it can contain nothing).
    
    Parameters:
    
    largerString - The target to look in
    
    substrings - A sequence of expected regular expressions, which must occur in the same order in the larger string
    
    Returns:
    
    True if the largerString contains all of the specified regular expressions in order.
  - fuzzyContainsRegex
```
public boolean fuzzyContainsRegex(String largerString,
                                  String... substrings)
```
    Determine whether one String contains a sequence of other substrings in order, where the expected substrings are specified as regular expressions, and respecting preferences for what differences matter. This method behaves just like fuzzyContains(String,String...), except that the second argument is interpreted as an array of regular expressions. String normalization rules are only appled to the larger string, not to the regular expressions.
    
    Parameters:
    
    largerString - The target to look in
    
    substrings - An array of expected substrings (interpreted as regular expression Patterns), which must occur in the same order in the larger string
    
    Returns:
    
    True if the largerString contains all of the specified substrings in order.
  - fuzzyContainsRegex
```
public boolean fuzzyContainsRegex(String largerString,
                                  Pattern... substrings)
```
    Determine whether one String contains a sequence of other substrings in order, where the expected substrings are specified as regular expressions, and respecting preferences for what differences matter. This method behaves just like fuzzyContains(String,String...), except that the second argument is interpreted as an array of regular expressions. String normalization rules are only appled to the larger string, not to the regular expressions.
    
    Parameters:
    
    largerString - The target to look in
    
    substrings - An array of expected substrings, which must occur in the same order in the larger string
    
    Returns:
    
    True if the largerString contains all of the specified substrings in order.
  - prepareIO
```
public void prepareIO()
```
    Resets IO and output reasons, then instruments IO for next method.
  - resetSystemIO
```
public static void resetSystemIO()
```
    An internal helper that resets the system part of the input/output buffering after each test case.
  - installExitHandler
```
public static void installExitHandler()
```
    This method is for internal use only and should not be called by other code. It is used to install System.exit() prevention control.
  - uninstallExitHandler
```
public static void uninstallExitHandler()
```
    This method is for internal use only and should not be called by other code. It is used to remove System.exit() prevention control after the test class has been completed.

Class TestCase

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class junit.framework.TestCase

Methods inherited from class java.lang.Object

Constructor Detail

TestCase

TestCase

Method Detail

setUp

tearDown

instrumentIO

resetIO

out

systemOut

systemErr

in

setIn

setIn

setSystemIn

multiline

fromFile

fromFile

stringNormalizer

setNormalizeLineEndings

setUseFuzzyStringComparisons

assertFuzzyEquals

assertFuzzyEquals

assertTrue

assertTrue

assertFalse

assertFalse

assertSame

assertSame

assertEquals

assertEquals

assertEquals

assertEquals

compact

compact

equals

fuzzyEquals

equalsRegex

equalsRegex

fuzzyEqualsRegex

fuzzyEqualsRegex

contains

fuzzyContains

containsRegex

containsRegex

fuzzyContainsRegex

fuzzyContainsRegex

prepareIO

resetSystemIO

installExitHandler

uninstallExitHandler