Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.sun.javatest
Class TestSuite

    java.lang.Object
      com.sun.javatest.TestSuite

    public class TestSuite

extends java.lang.Object

A class providing information about and access to the tests in a test suite. The primary methods to access and run the tests are

- `createTestFinder`
- `createTestFilter`
- `createScript`

Nested Class Summary
`static class` | `TestSuite.DuplicateLogNameFault`
`static class` | `TestSuite.Fault` An exception used to report errors while using a TestSUite object.
`static class` | `TestSuite.NoSuchLogFault`
`static class` | `TestSuite.NotTestSuiteFault` An exception that is used to report that a given file is not a test suite.

Field Summary
`static int` | `CLEAR_CHANGED_TEST` Should a test be reset to not run if it is found that the test has changed in the test suite (test description does not match the one in the existing result).
`static int` | `DELETE_NONTEST_RESULTS` Should tests which no longer exist in the test suite be deleted from a work directory when it is opened?
`static int` | `REFRESH_ON_RUN`

Constructor Summary
`TestSuite(java.io.File root)` Create a TestSuite object, with no additional test suite properties and no class loader.
`TestSuite(java.io.File root, java.util.Map tsInfo, java.lang.ClassLoader cl)` Create a TestSuite object.

Method Summary
`InterviewParameters` | `createInterview()` Create a configuration interview that can be used to collection the configuration data for a test run.
`java.util.logging.Logger` | `createLog(WorkDirectory wd, java.lang.String b, java.lang.String key)` Creates general purpose logger with given key and ResourceBundleName registered for given WorkDirectory.
`Script` | `createScript(TestDescription td, java.lang.String[] exclTestCases, TestEnvironment scriptEnv, WorkDirectory workDir, BackupPolicy backupPolicy)` Create and initialize a Script that can be used to run a test.
`TestFilter` | `createTestFilter(TestEnvironment filterEnv)` Create a test suite specific filter to be used to filter the tests to be selected for a test run.
`protected TestFinder` | `createTestFinder()` Create a test finder to be used to access the tests in this test suite.
`TestRunner` | `createTestRunner()` Create and initialize a TestRunner that can be used to run a series of tests.
`void` | `eraseLog(WorkDirectory wd)` Cleans the log file in given WorkDirectory
`protected java.lang.String[]` | `getAdditionalDocNames()` Get the names of any helpsets containing related documents for this test suite.
`javax.help.HelpSet[]` | `getAdditionalDocs()` Get helpsets containing any related documents for this test suite.
`java.lang.ClassLoader` | `getClassLoader()` Get the class loader specified when this test suite object was created.
`java.net.URL[]` | `getDocsForFolder(java.lang.String path)` This method should be overridden in subclasses
`java.net.URL[]` | `getDocsForTest(TestDescription td)` This method should be overridden in subclasses
`int` | `getEstimatedTestCount()` Get the estimated number of tests in the test suite.
`java.net.URL[]` | `getFilesForTest(TestDescription td)` Get a list of associated files for a specified test description.
`java.lang.String` | `getID()` Get a string containing a unique ID identifying this test suite, or null if not available.
`java.io.File` | `getInitialExcludeList()` Get the file name of the initial exclude list associated with the test suite.
`java.lang.String[]` | `getKeywords()` Get the set of valid keywords for this test suite.
`java.net.URL` | `getLatestExcludeList()` Get the URL for the latest exclude list associated with the test suite.
`java.util.logging.Logger` | `getLog(WorkDirectory wd, java.lang.String key)` Returns general purpose logger with given key registered for given WorkDirectory.
`java.net.URL` | `getLogo()` Get A URL identifying a logo for this test suite, or null if none available.
`java.lang.String` | `getName()` Get a string identifying this test suite, or null if not available.
`java.util.logging.Logger` | `getNotificationLog(WorkDirectory wd)`
`com.sun.javatest.logging.ObservedFile` | `getObservedFile(java.lang.String path)`
`com.sun.javatest.logging.ObservedFile` | `getObservedFile(WorkDirectory wd)`
`java.lang.String` | `getPath()` Get the path for the root file of this test suite.
`java.io.File` | `getRoot()` Get the root file of this test suite.
`java.io.File` | `getRootDir()` Get the root directory of this test suite.
`com.sun.javatest.services.ServiceManager` | `getServiceManager()`
`com.sun.javatest.services.ServiceReader` | `getServiceReader()` Returns a test suite specific ServiceReader, used to read Service definitions.
`TestFinder` | `getTestFinder()` Get a shared test finder to read the tests in this test suite.
`boolean` | `getTestRefreshBehavior(int event)` Get the requested behavior for dealing with conflicts between which tests are in the test suite vs those in the work directory.
`java.io.File` | `getTestsDir()` Get the directory in the test suite that contains the tests.
`protected java.util.Map` | `getTestSuiteInfo()` Get a map containing the test suite data in the .jtt file.
`java.lang.String` | `getTestSuiteInfo(java.lang.String name)` Get an entry from the data in the .jtt file.
`boolean` | `hasInitialExcludeList()` Check if the test suite has an initial exclude list.
`boolean` | `hasLatestExcludeList()` Check if the test suite has a latest exclude list.
`protected void` | `init(java.lang.String[] args)` Initialize this test suite, with args typically read from a .jtt file.
`static boolean` | `isTestSuite(java.io.File root)` Check if a file is the root of a valid test suite.
`java.lang.Class` | `loadClass(java.lang.String className)` Load a class using the class loader provided when this test suite was created.
`protected static java.lang.Class` | `loadClass(java.lang.String className, java.lang.ClassLoader cl)` Load a class using a specified loader, translating any errors that may arise into Fault.
`InterviewParameters` | `loadInterviewFromTemplate(java.io.File template, InterviewParameters ip)` Create a configuration interview based on specified template file
`InterviewParameters` | `loadInterviewFromTemplate(java.util.Properties templateInfo, InterviewParameters newInterview)` Create a configuration interview based on specified map of template values
`boolean` | `needServices()`
`protected static java.lang.Object` | `newInstance(java.lang.Class c)` Create a new instance of a class, translating any exceptions that may arise into Fault.
`protected static java.lang.Object` | `newInstance(java.lang.Class c, java.lang.Class[] argTypes, java.lang.Object[] args)` Create a new instance of a class using a non-default constructor, translating any exceptions that may arise into Fault.
`static TestSuite` | `open(java.io.File root)` Open a test suite.
`protected void` | `setTestFinder(TestFinder tf)` Set the shared test finder used to read the tests in this test suite.
`void` | `starting(Harness harness)` A notification method that is called when a test suite run is starting.

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

Field Detail

### DELETE_NONTEST_RESULTS

    public static final int DELETE_NONTEST_RESULTS

  Should tests which no longer exist in the test suite be deleted from a work directory when it is opened?

  See Also:
    Constant Field Values

### REFRESH_ON_RUN

    public static final int REFRESH_ON_RUN

See Also:
  Constant Field Values

### CLEAR_CHANGED_TEST

    public static final int CLEAR_CHANGED_TEST

  Should a test be reset to not run if it is found that the test has changed in the test suite (test description does not match the one in the existing result).

  See Also:
    Constant Field Values

Constructor Detail

### TestSuite

    public TestSuite(java.io.File root,
                     java.util.Map tsInfo,
                     java.lang.ClassLoader cl)
              throws TestSuite.Fault

  Create a TestSuite object.

  Parameters:
    `root` - The root file for this test suite.
    `tsInfo` - Test suite properties, typically read from the test suite properties file in the root directory of the test suite.
    `cl` - A class loader to be used to load additional classes as required, typically using a class path defined in the test suite properties file.
  Throws:
    `TestSuite.Fault` - if a problem occurs while creating this test suite.

### TestSuite

    public TestSuite(java.io.File root)

  Create a TestSuite object, with no additional test suite properties and no class loader.

  Parameters:
    `root` - The root file for this test suite.

Method Detail

### isTestSuite

    public static boolean isTestSuite(java.io.File root)

  Check if a file is the root of a valid test suite. A valid test suite is identified either by the root directory of the test suite, or by the file testsuite.html within that directory. The directory must contain either a test suite properties file (testsuite.jtt) or, for backwards compatibility, a file named testsuite.html.

  Parameters:
    `root` - The file to be checked.
  Returns:
    true if and only if root is the root of a valid test suite.

### open

    public static TestSuite open(java.io.File root)
                          throws java.io.FileNotFoundException,
                                 TestSuite.Fault,
                                 TestSuite.NotTestSuiteFault

  Open a test suite.

  Parameters:
    `root` - A file identifying the root of the test suite.
  Returns:
    A TestSuite object for the test suite in question. The actual type of the result will depend on the test suite properties found in the root directory of the test suite.
  Throws:
    `java.io.FileNotFoundException` - if root does not exist.
    `TestSuite.NotTestSuiteFault` - if root does not identify a valid test suite.
    `TestSuite.Fault` - if any other problems occur while trying to open the test suite.
  See Also:
    `isTestSuite(java.io.File)`

### init

    protected void init(java.lang.String[] args)
                 throws TestSuite.Fault

  Initialize this test suite, with args typically read from a .jtt file. The default implementation does not recognize any arguments and always throws an exception.

  Parameters:
    `args` - an array of strings to initialize this test suite object
  Throws:
    `TestSuite.Fault` - if there are any problems initializing the test suite from the specified arguments.

### getPath

    public java.lang.String getPath()

  Get the path for the root file of this test suite.

  Returns:
    the path for the root file of this test suite.

### getRoot

    public java.io.File getRoot()

  Get the root file of this test suite.

  Returns:
    the root file of this test suite.

### getRootDir

    public java.io.File getRootDir()

  Get the root directory of this test suite. If the root file is itself a directory, the result will be that directory; otherwise, the result will be the parent directory of the root file.

  Returns:
    the root directory of this test suite.

### getTestsDir

    public java.io.File getTestsDir()

  Get the directory in the test suite that contains the tests. By default, the following are checked:
  1. The `tests` property in the test suite properties file. If this entry is found, it must either identify an absolute filename, or a directory relative to the test suite root directory, using '/' to separate the components of the path.
  2. If the file root`/tests/testsuite.html` exists, the result is the directory root`/tests`. This is for compatibility with standard TCK layout.
  3. Otherwise, the result is the root directory of the test suite.

  Returns:
    the directory that contains the tests

### starting

    public void starting(Harness harness)
                  throws TestSuite.Fault

  A notification method that is called when a test suite run is starting. The method may be used to do any test suite specific initialization. If overriding this method, be sure to call the superclass' method. It is fairly typical to register as a harness observer inside this method. Note that if an exception occurs during this method, it will be caught by the harness and reported as a Harness.Observer.error(). It is recommended that any implementations of this method register as an observer immediately so that they can catch this error and do any cleanup to abort the test suite startup sequence (check if services were started and close them down, etc).

  Parameters:
    `harness` - The harness that will be used to run the tests.
  Throws:
    `TestSuite.Fault` - if an error occurred while doing test suite-specific initialization that should cause the test run to be aborted.

### createTestFilter

    public TestFilter createTestFilter(TestEnvironment filterEnv)

  Create a test suite specific filter to be used to filter the tests to be selected for a test run. The method should return null if no test suite specific filtering is required. The default is to return null.

  Parameters:
    `filterEnv` - Configuration data that may be used by the filter.
  Returns:
    a test suite filter, or null if no test suite specific filter is required for this test suite.

### getTestFinder

    public TestFinder getTestFinder()

  Get a shared test finder to read the tests in this test suite.

  Returns:
    a test finder to read the tests in this test suite
  See Also:
    `createTestFinder()`, `setTestFinder(com.sun.javatest.TestFinder)`

### setTestFinder

    protected void setTestFinder(TestFinder tf)

  Set the shared test finder used to read the tests in this test suite. Only one test finder may be set; attempts to change the test finder will cause IllegalStateException to be thrown. This method is normally called by TestSuite.open to initialize the finder to the result of calling createTestFinder.

  Parameters:
    `tf` - the test finder to be used
  Throws:
    `java.lang.IllegalStateException` - if the test finder has previously been set to a different value
  See Also:
    `getTestFinder()`

### createTestFinder

    protected TestFinder createTestFinder()
                                   throws TestSuite.Fault

  Create a test finder to be used to access the tests in this test suite. The default implementation looks for a `finder` entry in the test suite properties file, which should identify the class to be used and any arguments it may require. The class will be loaded via the class loader specified when the test suite was opened, if one was given; otherwise, the system class loader will be used. The default implementation attempts to use a file `testsuite.jtd` in the tests directory. If found, a BinaryTestFinder will be created using this file. If it is not found, then it searches for a property named `finder` in the test suite properties and will attempt to instantiate that. If no entry is found or it is blank, an HTMLTestFinder is used, using whatever a basic settings HTMLTestFinder initializes to.

  Returns:
    a test finder to be used to read the tests in the test suite
  Throws:
    `TestSuite.Fault` - if there is a problem creating the test finder
  See Also:
    `getTestFinder()`, `setTestFinder(com.sun.javatest.TestFinder)`, `getTestsDir()`

### createTestRunner

    public TestRunner createTestRunner()

  Create and initialize a TestRunner that can be used to run a series of tests. The default implementation returns a TestRunner that creates a number of test execution threads which each create and run a script for each test obtained from the test runners iterator.

  Returns:
    a TestRunner that can be used to run a series of tests

### createScript

    public Script createScript(TestDescription td,
                               java.lang.String[] exclTestCases,
                               TestEnvironment scriptEnv,
                               WorkDirectory workDir,
                               BackupPolicy backupPolicy)
                        throws TestSuite.Fault

  Create and initialize a Script that can be used to run a test. The default implementation looks for a `script` entry in the configuration data provided, and if not found, looks for a `script` entry in the test suite properties. The script entry should define the script class to use and any arguments it may require. The class will be loaded via the class loader specified when the test suite was opened, if one was given; otherwise, the system class loader will be used. Individual test suites will typically use a more direct means to create an appropriate script object. The parameters for this method are normally passed through to the script that is created. Note that the name of this method is "create", it is not recommended that the value returned ever be re-used or cached for subsequent requests to this method.

  Parameters:
    `td` - The test description for the test to be executed.
    `exclTestCases` - Any test cases within the test that should not be executed.
    `scriptEnv` - Configuration data to be given to the test as necessary.
    `workDir` - A work directory in which to store the results of the test.
    `backupPolicy` - A policy object used to control how to backup any files that might be overwritten.
  Returns:
    a script to be used to execute the given test
  Throws:
    `TestSuite.Fault` - if any errors occur while creating the script

### createInterview

    public InterviewParameters createInterview()
                                        throws TestSuite.Fault

  Create a configuration interview that can be used to collection the configuration data for a test run.

  The default implementation returns a `default` interview suitable for use with test suites built with earlier versions of the JT Harness: it provides questions equivalent to the fields in the GUI Parameter Editor or command-line -params option. As such, much of the necessary configuration data is provided indirectly via environment (.jte) files which must be created and updated separately.

  Individual test suites should provide their own interview, with questions customized to the configuration data they require. Note that the name of this method is "create", the harness may instantiate multiple copies for temporary use, resetting data or transferring data. Do not override this method with an implementation which caches the return value.

  Returns:
    A configuration interview to collect the configuration data for a test run.
  Throws:
    `TestSuite.Fault` - if a problem occurs while creating the interview

### loadInterviewFromTemplate

    public InterviewParameters loadInterviewFromTemplate(java.util.Properties templateInfo,
                                                         InterviewParameters newInterview)
                                                  throws TestSuite.Fault

  Create a configuration interview based on specified map of template values

  Returns:
    A configuration interview to collect the configuration data for a test run.
  Throws:
    `TestSuite.Fault` - if a problem occurs while creating the interview

### loadInterviewFromTemplate

    public InterviewParameters loadInterviewFromTemplate(java.io.File template,
                                                         InterviewParameters ip)
                                                  throws TestSuite.Fault,
                                                         java.io.IOException

  Create a configuration interview based on specified template file

  Returns:
    A configuration interview to collect the configuration data for a test run. null if specified file is not template
  Throws:
    `TestSuite.Fault` - if a problem occurs while creating the interview IOException if a problem occurs while reading a template file
    `java.io.IOException`

### getID

    public java.lang.String getID()

  Get a string containing a unique ID identifying this test suite, or null if not available. The default is taken from the "id" entry in the .jtt file.

  Returns:
    a unique ID identifying the test suite, or null if not specified.
  See Also:
    `getName()`

### getName

    public java.lang.String getName()

  Get a string identifying this test suite, or null if not available. The default is taken from the "name" entry in the .jtt file. This string is for presentation to the user, and may be localized if appropriate.

  Returns:
    a string identifying the test suite, or null if not specified.
  See Also:
    `getID()`

### getEstimatedTestCount

    public int getEstimatedTestCount()

  Get the estimated number of tests in the test suite. The default is to use the value of the "testCount" property from the testsuite.jtt file.

  Returns:
    The estimated number of tests, or -1 if this number is not available.

### getInitialExcludeList

    public java.io.File getInitialExcludeList()

  Get the file name of the initial exclude list associated with the test suite. The default is to use the value of the "initial.jtx" property from the testsuite.jtt file. If the value is a relative filename, it will be made absolute by evaluating it relative to the test suite root directory.

  Returns:
    the name of the default exclude list, or null if none specified.

### hasInitialExcludeList

    public boolean hasInitialExcludeList()

  Check if the test suite has an initial exclude list. The default is to use getInitialExcludeList, and if that returns a non-null result, check whether that file exists or not.

  Returns:
    true if the test suite has an initial exclude list, and false otherwise

### getLatestExcludeList

    public java.net.URL getLatestExcludeList()

  Get the URL for the latest exclude list associated with the test suite. The default is to use the value of the "latest.jtx" property from the testsuite.jtt file., which (if present) must be a fully qualified URL identifying the latest exclude list for this test suite.

  Returns:
    the name of the latest exclude list, or null if none specified.

### hasLatestExcludeList

    public boolean hasLatestExcludeList()

  Check if the test suite has a latest exclude list. The default is to use getLatestExcludeList, and to check whether that return a non-null result. The URL is not itself checked for validity.

  Returns:
    true if the test suite has a latest exclude list, and false otherwise

### getAdditionalDocs

    public javax.help.HelpSet[] getAdditionalDocs()
                                           throws TestSuite.Fault

  Get helpsets containing any related documents for this test suite. By default, the resource names for the help sets are obtained from getAdditionalDocNames().

  Returns:
    an array of help sets containing docs associated with this testsuite. The array will be empty if there are no such docs.
  Throws:
    `TestSuite.Fault` - if there are problems opening any of the helpsets.

### getAdditionalDocNames

    protected java.lang.String[] getAdditionalDocNames()

  Get the names of any helpsets containing related documents for this test suite. The names should identify JavaHelp helpset files, as used by javax.help.HelpSet.findHelpSet(ClassLoader, String). Thus the names should identify resources of helpsets on the classpath. This means you will typically need to put the directory or jar file containing the help set on the classpath as well. By default, the names will be looked up under the name "additionalDocs" in the testsuite.jtt file.

  Returns:
    an array of names identifying helpsets that contain related documents for this testsuite. The result may be null if there are no such documents.

### getKeywords

    public java.lang.String[] getKeywords()

  Get the set of valid keywords for this test suite. By default, the keywords will be looked up under the name "keywords" in the testsuite.jtt file.

  Returns:
    the set of valid keywords for this test suite, or null if not known.

### getFilesForTest

    public java.net.URL[] getFilesForTest(TestDescription td)

  Get a list of associated files for a specified test description. Normally, this will include the file containing the test description, and any source files used by the test. By default, the source files are determined from the test description's "source" entry.

  Parameters:
    `td` - The test description for which the associated files are required
  Returns:
    a list of associated files for this test description

### getDocsForFolder

    public java.net.URL[] getDocsForFolder(java.lang.String path)

  This method should be overridden in subclasses

  Parameters:
    `path` - String, which determines path to currently selected test's folder. This is root relative path. This shouldn't be null, for the root folder use "".
  Returns:
    array of files with documentation for test's folder, determined by path. null means there no documentation for this folder

### getDocsForTest

    public java.net.URL[] getDocsForTest(TestDescription td)

  This method should be overridden in subclasses

  Parameters:
    `td` - TestDescription for currently selected test case. This shouldn't be null.
  Returns:
    array of files with documentation for test case, determined td. null means there no documentation for this test case

### getLogo

    public java.net.URL getLogo()

  Get A URL identifying a logo for this test suite, or null if none available.

  Returns:
    a URL for a logo for the testsuite, or null if not available

### newInstance

    protected static java.lang.Object newInstance(java.lang.Class c)
                                           throws TestSuite.Fault

  Create a new instance of a class, translating any exceptions that may arise into Fault.

  Parameters:
    `c` - the class to be instantiated
  Returns:
    an instance of the specified class
  Throws:
    `TestSuite.Fault` - if any errors arise while trying to instantiate the class.

### newInstance

    protected static java.lang.Object newInstance(java.lang.Class c,
                                                  java.lang.Class[] argTypes,
                                                  java.lang.Object[] args)
                                           throws TestSuite.Fault

  Create a new instance of a class using a non-default constructor, translating any exceptions that may arise into Fault.

  Parameters:
    `c` - the class to be instantiated
    `argTypes` - the types of the argument to be passed to the constructor, (thus implying the constructor to be used.)
    `args` - the arguments to be passed to the constructor
  Returns:
    an instance of the specified class
  Throws:
    `TestSuite.Fault` - if any errors arise while trying to instantiate the class.

### loadClass

    public java.lang.Class loadClass(java.lang.String className)
                              throws TestSuite.Fault

  Load a class using the class loader provided when this test suite was created.

  Parameters:
    `className` - the name of the class to be loaded
  Returns:
    the class that was loaded
  Throws:
    `TestSuite.Fault` - if there was a problem loading the specified class

### loadClass

    protected static java.lang.Class loadClass(java.lang.String className,
                                               java.lang.ClassLoader cl)
                                        throws TestSuite.Fault

  Load a class using a specified loader, translating any errors that may arise into Fault.

  Parameters:
    `className` - the name of the class to be loaded
    `cl` - the class loader to use to load the specified class
  Returns:
    the class that was loaded
  Throws:
    `TestSuite.Fault` - if there was a problem loading the specified class

### getClassLoader

    public java.lang.ClassLoader getClassLoader()

  Get the class loader specified when this test suite object was created.

  Returns:
    the class loader specified when this test suite object was created

### getServiceManager

    public com.sun.javatest.services.ServiceManager getServiceManager()

### needServices

    public boolean needServices()

### getServiceReader

    public com.sun.javatest.services.ServiceReader getServiceReader()

  Returns a test suite specific ServiceReader, used to read Service definitions.

  Returns:
    ServiceReader instance. Default is XMLServiceReader

### getTestSuiteInfo

    protected java.util.Map getTestSuiteInfo()

  Get a map containing the test suite data in the .jtt file.

  Returns:
    a map containing the test suite data in the .jtt file

### getTestSuiteInfo

    public java.lang.String getTestSuiteInfo(java.lang.String name)

  Get an entry from the data in the .jtt file.

  Parameters:
    `name` - The name of the entry to get from the info in the .jtt file
  Returns:
    the value of the specified entry, or null if not found.

### getTestRefreshBehavior

    public boolean getTestRefreshBehavior(int event)

  Get the requested behavior for dealing with conflicts between which tests are in the test suite vs those in the work directory.

  See Also:
    `DELETE_NONTEST_RESULTS`, `REFRESH_ON_RUN`, `CLEAR_CHANGED_TEST`

### getNotificationLog

    public java.util.logging.Logger getNotificationLog(WorkDirectory wd)

### getObservedFile

    public com.sun.javatest.logging.ObservedFile getObservedFile(WorkDirectory wd)

### getObservedFile

    public com.sun.javatest.logging.ObservedFile getObservedFile(java.lang.String path)

### createLog

    public java.util.logging.Logger createLog(WorkDirectory wd,
                                              java.lang.String b,
                                              java.lang.String key)
                                       throws TestSuite.DuplicateLogNameFault

  Creates general purpose logger with given key and ResourceBundleName registered for given WorkDirectory.

  Parameters:
    `wd` - WorkDirectory logger should be registered for; may be `null` if no WorkDirectory currently available (the log will be registered for the first WD created for this TestSuite
    `b` - name of ResorceBundle used for this logger; may be `null` if not required
    `key` - key for this log
  Returns:
    general purpose logger with given key registered for given WorkDirectory or TestSuite (if WD is null)
  Throws:
    `TestSuite.DuplicateLogNameFault` - if log with this key has been registered in the system already
  See Also:
    `getLog(com.sun.javatest.WorkDirectory, java.lang.String)`

### getLog

    public java.util.logging.Logger getLog(WorkDirectory wd,
                                           java.lang.String key)
                                    throws TestSuite.NoSuchLogFault

  Returns general purpose logger with given key registered for given WorkDirectory. The log should be created first.

  Parameters:
    `wd` - WorkDirectory desired logger is registered for
    `key` - key for this log
  Returns:
    general purpose logger with given key registered for given WorkDirectory
  Throws:
    `TestSuite.NoSuchLogFault` - if desired log not registered in the system
    `java.lang.NullPointerException` - if `wd` is null
  See Also:
    `createLog(com.sun.javatest.WorkDirectory, java.lang.String, java.lang.String)`

### eraseLog

    public void eraseLog(WorkDirectory wd)
                  throws java.io.IOException

  Cleans the log file in given WorkDirectory

  Parameters:
    `wd` - WorkDirectory desired logger is registered for
  Throws:
    `java.io.IOException` - if log file's content can't be erased

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.