PATENT DOCUMENT

Abstract:
A mechanism has been developed for transforming different test suites, written for different test harnesses, into a common XML-type format that can be read by one test harness. Thus differences in the structure of the test suites is transparent to the test harness. To implement this mechanism, a component has been developed that parses XML descriptors and provides an API to the test harness.

Full Description:
CROSS-REFERENCE TO RELATED APPLICATIONS  
       [0001]     This application is related to Application No. (STC File No. 47900), entitled “Automated Test Execution Framework with Central Management”. 
     
    
     BACKGROUND OF THE INVENTION  
       [0002]     1. Field of the Invention  
         [0003]     This invention relates to improvements in software and hardware design verification. More particularly, this invention relates to methods and systems for centrally managing the execution of multiple design verification test suites that were written for use by different test harnesses or frameworks.  
         [0004]     2. Description of the Related Art  
         [0005]     The meanings of acronyms and certain terminology used herein are given in Table 1. The terms Sun, Sun Microsystems, Java, J2EE, J2ME, J2SE, and the Sun logo are trademarks or registered trademarks of Sun Microsystems, Inc., in the United States of America and other countries. All other company and product names may be trademarks of their respective companies. A portion of the disclosure of this patent document contains material that is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.  
                           TABLE 1                                       API   Application programming interface           CLDC   Connected, limited device configuration. CLDC is               suitable for devices with 16/32-bit RISC/CISC               microprocessors/controllers, having as little               as 160 KB of total memory available.           DTD   Document type definition           HTML   Hypertext markup language           JAXP   Java API for XML Processing           J2EE   Java 2 Enterprise Edition           J2ME   Java 2 Micro Edition           J2SE   Java 2 Standard Edition           JAD   Java application descriptor           JAR   Java archive           JTDS   Java Device Test Suite Execution Framework           MIDlet   A MIDP application           MIDP   Mobile information device profile. A set of Java               APIs, which, together with the CLDC, provides a               complete J2ME application runtime environment               targeted at mobile information devices.           XML   Extensible markup language           XTRF   XML test representation format                      
 
         [0006]     Tools have been developed in recent years to aid in the design verification of hardware and software systems, for example software suites, hardware circuitry, and programmable logic designs. In order to assure that the design complies with its specifications, it is common to generate a large number of input or instruction sequences to assure that the design operates as intended under a wide variety of circumstances. In general, test systems produce a report indicating whether tests have been passed or failed, and, in some cases may even indicate a module that is estimated to be faulty.  
         [0007]     Conventionally, test systems employing complex test suites employ a computer-implemented testing framework for computing devices, such as mobile information devices, and for software designed to run on such devices. A developer submits a computing product under development, typically a computing device or software that is designed to run on the device to the test system, which runs a selected battery of test programs on the product while monitoring its behavior. Each product under test requires an instance of an execution test harness, or the use of a stand-alone test execution API.  
         [0008]     In environments where testing of a product is ongoing, different aspects may be tested by different teams. As test results are evaluated, it is often necessary to revise the product under test, or to modify the test suites themselves. In such an environment, communicating such revisions to the different testing teams, maintaining version control, synchronization among the teams, and generally coordinating the testing activities is a difficult management problem. Errors could result in inappropriate testing, thus wasting valuable time and testing resources. Indeed, failure of coordination could result in the release of an inadequately tested product into the marketplace. A related problem when many test suites are being concurrently executed is the effort of setting up each test suite with its own test harness and environment. Bundling the test harness with the test suite is not a good solution, as the effort in maintaining up-to-date versions becomes formidable as the number of concurrently operating test suites increases, and when the product or the test suites are frequently modified by different test teams.  
       SUMMARY OF THE INVENTION  
       [0009]     In the above noted Application No. (STC File No. 47900), which is commonly assigned herewith, and herein incorporated by reference, a test framework having a central repository and a management unit is disclosed. The central repository contains available test suites and a single test execution harness. An example of the latter is described in commonly assigned application Ser. No. 10/347,748, entitled “Generating Standalone MIDlets from a Testing Harness”, which is herein incorporated by reference.  
         [0010]     Using the management unit, a system administrator is enabled to control active versions of the various test suites, and their individual configurations. End users of this system install clients of the central repository, using a system-provided installer program. These clients constitute test harnesses. At the client, an execution script and a local configuration file are created. When the test harness is to be executed, it loads with all designated test suites being installed, configured and ready for execution. The client always has the most updated versions of all test suites, as configured by the system administrator, using the management unit. This system operates from a single central location, without need for distributing local copies of the test harness or test suites, which could lead to loss of synchronization as updates are developed.  
         [0011]     The arrangement disclosed in the above noted Application No. (STC File No. 47900) does not fully address the situation in which the test framework is required to execute different test suites, which have been designed for different test harnesses. In order to execute these test suites, it has previously been necessary to implement each harness with individual configurations for each of the various test suites, and to separately execute the test suites. Alternatively, the test suites could be rewritten for one harness. Both solutions are time consuming and error prone.  
         [0012]     A mechanism has been developed for transforming different test suites, written for different test harnesses, into a common XML format that can be read by one test harness. Thus, differences in the structure of the test suites are transparent to the test harness. To implement this mechanism, a component has been developed, which parses XML descriptors and provides an API to the test harness.  
         [0013]     The invention provides a method for testing computing devices, which is carried out by providing a plurality of suites of test programs on a server for execution by one or more computing devices that are coupled to the server, wherein the suites are represented in a plurality of formats. The method is further carried out by converting the suites to a common representation, processing the common representation in the server to define suites of converted test programs, and downloading the converted test programs from the server to the computing devices for execution.  
         [0014]     An aspect of the method includes controlling the execution of the converted test programs by the computing devices from the server, using no more than one test harness.  
         [0015]     In one aspect of the method conversion of the suites to the common representation is accomplished by converting the suites to a common intermediate format, and thereafter converting the common intermediate format to a native format for use in processing the common representation in the server.  
         [0016]     According to another aspect of the method, the common intermediate format is a markup language.  
         [0017]     According to a further aspect of the method, the markup language is XML, and the suites are converted into XTRF files.  
         [0018]     The invention provides a computer software product, including a computer-readable medium in which computer program instructions are stored, which instructions, when read by a computer, cause the computer to perform a method for testing computing devices, which is carried out by inputting a plurality of suites of test programs on a server for execution by one or more computing devices that are coupled to the server, wherein the suites are represented in a plurality of formats. The method is further carried out by converting the suites to a common representation, processing the common representation into suites of converted test programs, downloading the converted test programs to the computing devices for execution thereof by the computing devices, and controlling the execution of the converted test programs by the computing devices.  
         [0019]     The invention provides a server apparatus for testing computing devices, including a communication interface for coupling a plurality of the computing devices therewith, and a processor, which is adapted to provide a suite of test programs for execution by the computing devices, and to download the test programs via the communication interface for execution by the computing devices coupled thereto. The processor is further adapted to control the execution by the computing devices, wherein the test programs are initially input to the server apparatus in a plurality of formats. The processor is further adapted to convert the plurality of formats into a common format for download thereof to the computing devices. 
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0020]     For a better understanding of the present invention, reference is made to the detailed description of the invention, by way of example, which is to be read in conjunction with the following drawings, wherein like elements are given like reference numerals, and wherein:  
         [0021]      FIG. 1  is a block diagram of a system for centrally managing the execution of multiple test suites, which have been written for different test harnesses;  
         [0022]      FIG. 2  is a high level functional block diagram of an implementation of a platform editor in the system of  FIG. 1 , in accordance with a disclosed embodiment of the invention;  
         [0023]      FIG. 3  is a flow chart illustrating the transformation of a foreign test suite into a native test suite in accordance with a disclosed embodiment of the invention; and  
         [0024]      FIG. 4  is a block diagram illustrating the generation and processing of a XTRF file according to a disclosed embodiment of the invention. 
     
    
     DETAILED DESCRIPTION OF THE INVENTION  
       [0025]     In the following description, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be apparent to one skilled in the art, however, that the present invention may be practiced without these specific details. In other instances well-known circuits, control logic, and the details of computer program instructions for conventional algorithms and processes have not been shown in detail in order not to unnecessarily obscure the present invention.  
         [0026]     Software programming code, which embodies aspects of the present invention, is typically maintained in permanent storage, such as a computer readable medium. In a client/server environment, such software programming code may be stored on a client or a server. The software programming code may be embodied on any of a variety of known media for use with a data processing system, This includes, but is not limited to, magnetic and optical storage devices such as disk drives, magnetic tape, compact discs (CD&#39;s), digital video discs (DVD&#39;s), and computer instruction signals embodied in a transmission medium with or without a carrier wave upon which the signals are modulated. For example, the transmission medium may include a communications network, such as the Internet.  
         [0000]     System Architecture.  
         [0027]     Turning now to the drawings, reference is initially made to  FIG. 1 , which is a high level block diagram of a system  10  for centrally managing the simultaneous or sequential execution of multiple test suites that have been written for different platforms for verifying different hardware and software, in accordance with a disclosed embodiment of the invention. The heart of the system  10  is a central repository  12 , which can reside on a local or a remote server, and which contains data structures necessary for multiple clients of the central repository  12  to perform testing simultaneously, or at different times. The central repository  12  holds data structures that define platforms  14 , test suites  16 , an execution test harness  18 , and an installer  20 . The installer  20  creates a script for launching the framework. The script includes paths to binary files of the test execution framework. The binaries themselves are located in only one place, the central repository  12 . Centrally locating the binary files is highly advantageous, as only one instance of each binary file need be updated. Furthermore, each user is guaranteed to see the most current version of the framework. Because distribution of local copies of the binaries is avoided, users need not be concerned about having outdated software. The execution test harness  18  may be implemented as a modification of the test framework “Java Device Test Suite” execution framework (JDTS) (version 1.0 or higher), available from Sun Microsystems, Inc., Palo Alto, Calif., which employs MIDP.  
         [0028]     Alternatively, it is possible to practice the invention using distributed data repositories, so long as they are accessible to a central management module.  
         [0029]     Typically the installation is packaged in an archive, such as a JAR file. The system  10  is capable of being controlled by a single operator  22 , using a client terminal  24 . However, in many environments it is desirable that a superuser, or administrator  26  manage the central repository  12 . This is done using a platform editor  28 , which acts as a management unit. Using the platform editor  28 , the administrator  26  is capable of reconfiguring the platforms  14 , test suites  16 , execution test harness  18 , and installer  20 . An end user  30  interacts with the central repository  12  via a client terminal  32 . The end user  30  launches an execution package, which is first downloaded and installed from the central repository  12 . The end user  30  and the terminal  32  may be co-located with the other components of the system  10 , or alternatively may be located remotely and connected to the central repository  12  via a data network. Although only one instance of the end user  30  is shown, it will be understood that many end users can interact with the central repository  12  concurrently, or at different times, using the same or different platforms and the same or different test suites. The end user  30  and the terminal  32  are referred to hereinbelow as a client  34 .  
         [0030]     In addition to handling native test suites, the system  10  is capable of managing foreign test suites, which were originally written for previous versions of the test harness  18 , or even other test harnesses, thus allowing such foreign test suites to be recycled. This is accomplished using a conversion module  19 , which converts test suites in diverse formats to a common intermediate representation, which is one or more XTRF files. A parser  21  then converts the XTRF files into a native format suitable for the test harness  18 . The test suites  16  may be stored in the native format for immediate use by the test harness  18 . Alternatively, they may be stored as XTRF files, and submitted to the parser  21  when needed by the test harness  18 . Using this arrangement, any number of test programs and different test suites can be executed using no more than one test harness.  
         [0031]     The system  10  is suitable for use in many development environments, including MIDlet development using J2ME. It may be adapted to J2EE and J2SE environments using programming techniques known to the art.  
         [0000]     System—Functional Organization.  
         [0032]     Continuing to refer to  FIG. 1 , the central repository  12  contains test parameters, platform configuration parameters, framework parameters and the tests themselves. The end user  30  makes use of the central repository  12  in a “session”. In an implementation of a session for a framework application in the execution state, contents of the central repository  12  are stored and loaded. The disclosure of the system implementation is common to the platform editor  28 , which manages platforms using the central repository  12 , and to other aspects of the execution framework, such as the installer  20 . The installer  20  creates an execution script and local configuration files. The execution test harness  18  is not downloaded. Its binary files remain on the central repository  12 .  
         [0033]     Reference is now made to  FIG. 2 , which is a high level functional block diagram of an implementation of the platform editor  28  ( FIG. 1 ) in accordance with a disclosed embodiment of the invention. A class PlatformSessionManager  36  has methods for loading and saving platforms and sessions.  
         [0034]     A class Platform  38  encapsulates all platform specific information. An instance of the class Platform  38  includes such information as available test suites, and their respective properties, as well as other platform-specific information. The test suites and their properties are managed by a class TestSuitesManager  40 . Platform-specific information is managed by a class EnvironmentView  42 . Tests in the test suites can be excluded from performance by a class ExcludedTestsView  44 .  
         [0035]     A class Session  46  encapsulates all information specified by the client  34  ( FIG. 1 ). Such client specific information includes the basic properties of the test suites and the platform that applies to a particular session of the client  34 .  
         [0036]     The class Platform  38  and the class Session  46  interact with the class TestSuitesManager  40 , the class EnvironmentView  42 , and the class ExcludedTestsView  44 .  
         [0037]     The class TestSuitesManager  40  interacts with a table TestSuiteTable  48 , which contains records of the different test suites, as indicated by a class TestSuiteTable  50 .  
         [0038]     The class EnvironmentView  42  interacts with a table EnvironmentTable  52 , which contains records of known platform environments, as indicated by a representative table EnvironmentRecord  54 .  
         [0039]     The class ExcludedTestsView  44  interacts with a table ExcludedTestsTable  56 , which contains records of excluded tests, as indicated by a representative class ExcludedTestsRecord  58 .  
         [0040]     Records originating from the class TestSuiteTable  50 , the table EnvironmentRecord  54 , and the class ExcludedTestsRecord  58 , are included in a class record  60 , and initially written to an interface table  62 , before being ultimately transferred to an appropriate one of the table EnvironmentTable  52 , the table EnvironmentRecord  54 , or the table ExcludedTestsTable  56 .  
         [0041]     A class XMLAccessManager  64  accepts requests from the class TestSuitesManager  40 , the class EnvironmentView  42 , and the class ExcludedTestsView  44  for read or write operations to and from the class Platform  38  and the class Session  46 . The class XMLAccessManager  64  manages queues of read requests  66 , write requests  68 , and executes them sequentially.  
         [0042]     A class XMLAccess  70  contains a single access point to XML files that represent platforms and sessions. It has methods for read/write access to these XML files.  
         [0043]     Further details of the implementation of the platform editor  28  ( FIG. 1 ) are disclosed in the above noted Application No. (STC File No. 47900).  
         [0000]     Test Suite Transformation—General.  
         [0044]     Reference is now made to  FIG. 3 , which is a flow chart illustrating the transformation of a foreign test suite, which has been written for a test framework other than the test harness  18  ( FIG. 1 ), into a native test suite suitable for execution using the test harness  18  and a suitable target device in accordance with a disclosed embodiment of the invention. The target device could be the client terminals  24 ,  32 , or devices (not shown) attached thereto. This is accomplished by first converting the foreign test suite into a common intermediate file, a XTRF file, which is a XML representation of a test suite. The XTRF file is then parsed so as to generate a test suite, which is native to the test harness  18 .  
         [0045]     As shown in Listing  1 , which is a DTD of the XTRF format, a XTRF file describes the content of a test suite, that is the various classes, and tests it contains, and the parameters and external entities, which are used by the test suite. Other XML tags not shown in Listing  1  can optionally be included in a XTRF file.  
         [0046]     At initial step  76  a foreign test suite is selected. Next, at step  78  the foreign test suite is input into the conversion module  19 , which is capable of converting different foreign test suite formats into a common format, expressed as one or more XTRF files. The details of the conversion module are disclosed in further detail hereinbelow. In some embodiments, the intermediate XTRF files may be stored as the test suites  16  ( FIG. 1 ).  
         [0047]     Next, at step  80 , the XTRF files that were generated in step  78  are submitted to the parser  21 , which converts them into a native test suite representation  81  that is recognized by the test harness  18 . Listing  2  is a Java code package that implements a parser for use in step  80 .  
         [0000]     XTRF File Generation.  
         [0048]     Reference is now made to  FIG. 4 , which is a block diagram illustrating the generation and processing of a XTRF file according to a disclosed embodiment of the invention. A custom test suite  82  is typically written according to a custom API, which is different from the API of the Java Device Test Suite execution framework. Using the code fragment of Listing  3  a custom test suite representation can be scanned, and a XTRF generator  84  can be used to output a XTRF file  86  representing the test suite. This is accomplished using a XTRF Generator API, details of which are presented hereinbelow in Appendix 1.  
         [0000]     XTRF Parsing.  
         [0049]     Continuing to refer to  FIG. 4 , the XML descriptors contained in the XTRF file  86  are parsed by a parser  88 . The parser  88  provides an API to a test harness  90 , which could be the test harness  18  ( FIG. 1 ). Using the parser  88 , the test harness  90  is able to interpret and process the XTRF file  86 . Details of this API are given hereinbelow in Appendix 2.  
       EXAMPLE  
       [0050]     Continuing to refer to  FIG. 4 , a test prepared for a test harness other than the test harness  90  is presented in Listing  4 , and is an example of a portion of the test suite  82 , which in its present form is unacceptable to the test harness  90 . The program shown in Listing  4  can be submitted to the XTRF generator  84  and the parser  88 , as disclosed above. The final output of the parser  88  is acceptable to the test harness  90 .  
         [0051]     It will be appreciated by persons skilled in the art that the present invention is not limited to what has been particularly shown and described hereinabove. Rather, the scope of the present invention includes both combinations and subcombinations of the various features described hereinabove, as well as variations and modifications thereof that are not in the prior art, which would occur to persons skilled in the art upon reading the foregoing description.  
         [0000]     Computer Program Listings  
         [0052]     Imported modules stated in program listings hereinbelow are components of JAXP (ver 1.2 or higher) or other standard Java API&#39;s of J2SE, both available from Sun Microsystems, Inc.  
                                                             Listing 1                                    &lt;!DOCTYPE testsuite [                &lt;!ELEMENT group (class*)&gt;           &lt;!ATTLIST group name CDATA #REQUIRED&gt;           &lt;!ELEMENT class (testcase*)&gt;           &lt;!ATTLIST class name CDATA #REQUIRED&gt;           &lt;!ATTLIST class package CDATA #REQUIRED&gt;           &lt;!ELEMENT testcase (requiredclass*,property*,keyword*)&gt;           &lt;!ATTLIST testcase name CDATA #REQUIRED&gt;            &lt;!ELEMENT requiredclass EMPTY&gt;            &lt;!ATTLIST requiredclass name CDATA #REQUIRED&gt;            &lt;!ELEMENT property EMPTY&gt;            &lt;!ATTLIST property name CDATA #REQUIRED&gt;            &lt;!ELEMENT keyword EMPTY&gt;            &lt;!ATTLIST keyword name CDATA #REQUIRED&gt;            &lt;ELEMENT testsuite EMPTY&gt;            &lt;!ATTLIST testsuite name CDATA #REQUIRED&gt;                ]&gt;                      
 
         [0053]    
       
         
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
           
               
                   
               
               
                   
               
               
                 Listing 2 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 package com.sun.xtrf.parser; 
               
               
                 import java.io.*; 
               
               
                 import org.w3c.dom.*; 
               
               
                 import javax.xml.parsers.DocumentBuilderFactory; 
               
               
                 import javax.xml.parsers.DocumentBuilder; 
               
               
                 import org.xml.sax.SAXException; 
               
               
                 import org.xml.sax.SAXParseException; 
               
               
                 import com.sun.xml.tree.*; 
               
               
                 import java.lang.reflect.*; 
               
               
                 import java.util.*; 
               
               
                 class XTRFParser 
               
               
                 { 
               
               
                 private static GroupMap groupMap = new GroupMap( ); 
               
             
          
           
               
                   
                 public void init( ) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                 try 
               
               
                   
                 { 
               
             
          
           
               
                   
                 //load all tags handlers classes from properties file 
               
               
                   
                 Properties propertiesFile = new Properties( ); 
               
               
                   
                 propertiesFile.load(this.getClass( ).getResourceAsStream 
               
             
          
           
               
                   
                 (“xtrf.properties”)); 
               
             
          
           
               
                   
                 //load tag handlers 
               
               
                   
                 String str = properties 
               
             
          
           
               
                   
                 File.getProperty(“tagHandlers.list”); 
               
             
          
           
               
                   
                 //get the name of the class 
               
               
                   
                 StringTokenizer token = new StringTokenizer(str, “;”); 
               
               
                   
                 while(token.hasMoreElements( )) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 //create instance of each class 
               
               
                   
                 Class cls = Class.forName(token.nextToken( )); 
               
               
                   
                 cls.newInstance( ); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
               
                   
                 catch(Exception e) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 System.err.println(“An exception has occurred 
               
               
                   
                  during the class 
               
               
                   
                  loading ”+ 
               
             
          
           
               
                   
                  e.getClass( ).getName( ) + “: ” + e.getMessage( ) ); 
               
             
          
           
               
                   
                 e.printStackTrace(System.err); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 /** 
               
               
                   
                  * Parsing a XML document stored in a file. 
               
               
                   
                  **/ 
               
               
                   
                  TestGroup getRoot(File f) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                 Document doc; 
               
               
                   
                 Element el=null; 
               
               
                   
                 try { 
               
             
          
           
               
                   
                 DocumentBuilderFactory docBuilderFactory = Document 
               
               
                   
                 BuilderFactory.newInstance( ); 
               
               
                   
                 DocumentBuilder docBuilder = 
               
             
          
           
               
                   
                 docBuilderFactory.newDocumentBuilder( ); 
               
             
          
           
               
                   
                 doc = docBuilder.parse (f); 
               
               
                   
                 el = doc.getDocumentElement ( ); 
               
               
                   
                 // normalize text representation 
               
               
                   
                 el.normalize ( ); 
               
               
                   
                 System.out.println (“Root element of the doc is ” + 
               
             
          
           
               
                   
                 doc.getDocumentElement( ).getNodeName( )); 
               
             
          
           
               
                   
                 } catch (SAXParseException err) { 
               
             
          
           
               
                   
                 System.out.println (“** Parsing error” 
               
             
          
           
               
                   
                 + “, line ” + err.getLineNumber ( ) 
               
               
                   
                 + “, uri ” + err.getSystemId ( )); 
               
             
          
           
               
                   
                 System.out.println(“ 
                 ” + err.getMessage ( )); 
               
             
          
           
               
                   
                 // print stack trace as below 
               
             
          
           
               
                   
                 } catch (SAXException e) { 
               
             
          
           
               
                   
                 Exception x = e.getException ( ); 
               
               
                   
                 ((x == null) ? e : x).printStackTrace ( ); 
               
             
          
           
               
                   
                 } catch (Throwable t) { 
               
             
          
           
               
                   
                 t.printStackTrace ( ); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 //System.exit (0); 
               
               
                   
                 groupMap.init( ); 
               
               
                   
                 return loadGroup(el); 
               
               
                   
                 //additionalMap.init( ); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 private TestGroup loadGroup(Element el) 
               
               
                 { 
               
               
                 Class[ ] param={Element.class,XTRFParser.class}; 
               
               
                 Object[ ] obj = {el,new XTRFParser( )}; 
               
               
                 TestGroup testGroup=null; 
               
               
                 try 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                 Class cls = 
               
               
                   
                 Class.forName((String)groupMap.get(el.getNodeName( ))); 
               
               
                   
                 Constructor constructor = 
               
               
                   
                  cls.getDeclaredConstructor(param); 
               
               
                   
                 testGroup=(TestGroup)constructor.newInstance(obj); 
               
               
                   
                 NamedNodeMap attr=el.getAttributes( ); 
               
               
                   
                 processAttributes(attr,testGroup); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 catch(Exception e) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                 e.getMessage( ); 
               
               
                   
                 e.printStackTrace( ); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 return testGroup; 
               
               
                 } 
               
               
                 void processAttributes(NamedNodeMap attr,TestGroup testGroup) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                 if(attr!=null) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                 for(int j=0;j &lt; attr.getLength( ); j++) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 testGroup.putAttribute(attr.item(j). 
               
             
          
           
               
                   
                 getNodeName( ),attr.item(j). 
               
               
                   
                 getNodeValue( )); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
               
                   
                 TestGroup[ ] parse(Element el,TestGroup parent) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 NodeList nodeList = el.getChildNodes( ); 
               
               
                   
                 LinkedList groups=new LinkedList( ); 
               
               
                   
                 TestGroup testGroup=null; 
               
               
                   
                 for(int i=0; i &lt; nodeList.getLength( ); i++) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 Node child = nodeList.item(i); 
               
               
                   
                 String name = nodeList.item(i).getNodeName( ); 
               
               
                   
                 if(groupMap.has(name)) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 try 
               
               
                   
                 { 
               
             
          
           
               
                   
                 Class[ ] param={Element.class,XTRFParser.class}; 
               
               
                   
                 Object[ ] obj={child,this}; 
               
               
                   
                 Class cls = Class.forName((String) 
               
             
          
           
               
                   
                 groupMap.get(name)); 
               
             
          
           
               
                   
                 Constructor constructor = 
               
             
          
           
               
                   
                 cls.getDeclaredConstructor(param); 
               
             
          
           
               
                   
                 testGroup=(TestGroup)constructor.newInstance(obj) 
               
               
                   
                 testGroup.addParent(parent); 
               
               
                   
                 NamedNodeMap attr=child.getAttributes( ); 
               
               
                   
                 processAttributes(attr,testGroup); 
               
               
                   
                 if(! (testGroup instanceof RequiredClassHandler)) 
               
               
                   
                 groups.add(testGroup); 
               
               
                   
                 } 
               
               
                   
                 catch(Exception e) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 e.getMessage( ); 
               
               
                   
                 e.printStackTrace(System.err); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
               
                   
                 NodeList newLs = child.getChildNodes( ); 
               
               
                   
                 if(newLs!=null) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 for(int j=0; j &lt; newLs.getLength( ); j++) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 TestGroup newTestGroup = null; 
               
               
                   
                 child = newLs.item(j); 
               
               
                   
                 name = newLs.item(j).getNodeName( ); 
               
             
          
           
               
                   
                 Registration regist = new Registration( ); 
               
               
                   
                 if(regist.has(name)) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 TagHandler handler = regist.get(name); 
               
               
                   
                 handler.handleTag(testGroup,child); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
               
                   
                 TestGroup tGroups[ ] = new TestGroup[groups.size( )]; 
               
               
                   
                 for(int i=0;i &lt; groups.size( ); i++) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 System.out.println(i); 
               
               
                   
                 tGroups[i]=(TestGroup)groups.get(i); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 return tGroups; 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 } 
               
               
                   
               
             
          
         
       
     
         [0054]    
       
         
               
             
               
             
               
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
             
           
               
                   
               
               
                   
               
               
                 Listing 3 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 import com.sun.xtrf.generator.*; 
               
               
                 //this is the XTRF API package (xtrf api) 
               
               
                 import java.lang.reflect.Method; 
               
               
                 import java.io.*; 
               
               
                 import java.util.*; 
               
               
                 import java.net.*; 
               
               
                 public class TckGenerator 
               
               
                 { 
               
             
          
           
               
                   
                 public static void main(String[ ] args) { 
               
             
          
           
               
                   
                 TckGenerator gen = new TckGenerator( ); 
               
               
                   
                 gen.generate(args[0], args[1]); 
               
             
          
           
               
                 } 
               
               
                 //directory that containes test sources 
               
               
                 String sourceDir; 
               
               
                 Map hash = new HashMap( ); 
               
               
                 Map tmpHash =new HashMap( ) ; 
               
               
                 TagGenerator ancestor; 
               
               
                 String[ ] globalArgs; 
               
               
                 /** 
               
               
                 * creates components that read tck test suite files 
               
               
                 * and perform generating 
               
               
                 **/ 
               
               
                 public void generate(String outputDir,String inputDir) 
               
               
                 { 
               
             
          
           
               
                   
                 XtrfGenerator gen = new XtrfGenerator(outputDir); 
               
               
                   
                 //part of the XTRF Generator API 
               
               
                   
                 //it&#39;s used to start new xtrf document 
               
               
                   
                 TagGenerator root = gen.createRoot(“testsuite.xml”); 
               
               
                   
                 //create root of the document 
               
               
                   
                 //call the document “testsuite.xml” 
               
               
                   
                 ancestor=root; 
               
               
                   
                 generateTree(root,inputDir); 
               
               
                   
                 gen.finishGenerating( ); 
               
             
          
           
               
                 } 
               
               
                 /** 
               
               
                 * generates the xtrf file that will be read by the framework 
               
               
                 **/ 
               
               
                 private void generateTree(TagGenerator root, String inputDir) 
               
               
                 { 
               
             
          
           
               
                   
                 File testSuite = null; 
               
               
                   
                 String logFileName = null; 
               
               
                   
                 String outputFileName = “testsDescr.txt”; 
               
               
                   
                 int tfMode = 2; 
               
               
                   
                 boolean needTestCases = true; 
               
               
                   
                 File[ ] initialFiles = null; 
               
               
                   
                 String prevDir=null; 
               
               
                   
                 TagGenerator groupRoot=root; 
               
               
                   
                 Map map = new HashMap( ); 
               
               
                   
                 testSuite = new File(inputDir); 
               
               
                   
                 //This method takes all tests related info from the tck 
               
               
                   
                 // test suite and converts it to xtrf format 
               
               
                   
                 File f = new File(testSuite, “..” + File.separator + 
               
               
                   
                  “classes” + File.separator + “shared” + File.separator + 
               
               
                   
                  “testClasses.lst”); 
               
               
                   
                 FileInputStream stream = null; 
               
               
                   
                 try 
               
               
                   
                 { 
               
             
          
           
               
                   
                 stream = new FileInputStream(f); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 catch(Exception e) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 e.getMessage( ); 
               
               
                   
                 e.printStackTrace( ); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 BufferedReader reader = new BufferedReader(new 
               
               
                   
                  InputStreamReader(stream)); 
               
               
                   
                 String line; 
               
               
                   
                 try 
               
               
                   
                 { 
               
             
          
           
               
                   
                 while((line = reader.readLine( ))!=null) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 map.put(line.substring(0,line.indexOf 
               
               
                   
                  (“ ”)).trim( ),line.substring(line.indexOf 
               
               
                   
                  (“ ”)+1,line.length( )).trim( )); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
               
                   
                 catch(Exception e) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 e.getMessage( ); 
               
               
                   
                 e.printStackTrace( ); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 try 
               
               
                   
                 { 
               
             
          
           
               
                   
                 testSuite = new File(inputDir); 
               
               
                   
                 testSuite = new File(testSuite.getCanonicalPath( )); 
               
               
                   
                 File testSuiteClasses = null; 
               
               
                   
                 if (needTestCases) { 
               
             
          
           
               
                   
                 if (testSuite.isDirectory( )) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 testSuiteClasses = new File(testSuite, “..” + 
               
               
                   
                  File.separator + “classes”); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 else 
               
               
                   
                 { 
               
             
          
           
               
                   
                 testSuiteClasses = new File(testSuite.getParent( ), 
               
               
                   
                 “..” + File.separator + “classes”); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 if (!testSuiteClasses.exists( )) 
               
               
                   
                 } 
               
             
          
           
               
                   
                 TestFinderWrapper tf=null; 
               
               
                   
                 tf = new TestFinderWrapper( ); 
               
               
                   
                 tf.setMode(tfMode); 
               
               
                   
                 tf.setRoot(testSuite); 
               
               
                   
                 if (logFileName != null) { 
               
             
          
           
               
                   
                 log = new PrintWriter(new BufferedWriter ( 
               
             
          
           
               
                   
                 new FileWriter(logFileName))); 
               
             
          
           
               
                   
                 tf.setVerify(true); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 TestFinderQueueWrapper tfq = new 
               
               
                   
                  ;TestFinderQueueWrapper( ); 
               
               
                   
                 tfq.setTestFinder(tf.getTestFinder( )); 
               
               
                   
                 tfq.setInitialFiles(testSuite, initialFiles); 
               
               
                   
                 TestDescriptionWrapper td; 
               
               
                   
                 while ((td = tfq.next( )) != null) { 
               
             
          
           
               
                   
                 String[ ] keywords = td.getKeywords( ); 
               
               
                   
                 String dir = td.getRootRelativePath( ).substring(0,td. 
               
               
                   
                  getRootRelativePath( ).indexOf(td.getDir( ).getName( )) 
               
               
                   
                  + td.getDir( ).getName( ).length( )); 
               
               
                   
                 root = createGroups(groupRoot,dir,prevDir); 
               
               
                   
                 groupRoot=root; 
               
               
                   
                 prevDir =dir; 
               
               
                   
                 if (needTestCases) { 
               
             
          
           
               
                   
                 String executeClassName = 
               
               
                   
                  td.getParameter(“executeClass”); 
               
               
                   
                 root = root.addChildTag(“class”, 
               
               
                   
                  executeClassName.substring 
               
               
                   
                  (executeClassName.lastIndexOf 
               
               
                   
                  (“.”)+1,executeClassName.length( ))); 
               
               
                   
                 //add info to xtrf using the api 
               
               
                   
                 if(executeClassName.indexOf(“.”)!=−1) 
               
             
          
           
               
                   
                 root.setAttribute 
               
               
                   
                  (“package”,executeClassName.substring 
               
               
                   
                  (0,executeClassName.lastIndexOf(“.”))); 
               
             
          
           
               
                   
                 String[ ] testCases = getTestCases 
               
               
                   
                 (td, testSuiteClasses,root); 
               
               
                   
                 TagGenerator temp = null; 
               
               
                   
                 if (testCases != null) { 
               
             
          
           
               
                   
                 for (int i = 0; i &lt; testCases.length; i++) { 
               
             
          
           
               
                   
                 if (!testCases[i].equals(“get Status”)) 
               
               
                   
                  { 
               
             
          
           
               
                   
                  temp=root; 
               
               
                   
                  root = root.addChildTag(“testcase”, 
               
             
          
           
               
                   
                 testCases[i]); 
               
             
          
           
               
                   
                  createRequiredClasses 
               
             
          
           
               
                 (root,td.getRootRelativeURL( ),map); 
               
             
          
           
               
                   
                  addKeywords(root,keywords); 
               
               
                   
                  root=temp; 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 catch(Exception e) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 e.getMessage( ); 
               
               
                   
                 e.printStackTrace( ); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 } 
               
               
                 private void addKeywords(TagGenerator root, String[ ] keywords) 
               
               
                 { 
               
             
          
           
               
                   
                 if(keywords !=null) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 for(int i=0; i &lt; keywords.length; i++) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 root.addChildTag(“keyword”,keywords[i]); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 } 
               
               
                 private void createRequiredClasses(TagGenerator root, String 
               
               
                 key,Map map) 
               
               
                 { 
               
             
          
           
               
                   
                 if(map.containsKey(key)) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 String values = (String)map.get(key); 
               
               
                   
                 StringTokenizer tok = new StringTokenizer(values, “,”); 
               
               
                   
                 while(tok.hasMoreElements( )) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 String t = tok.nextToken( ).trim( ); 
               
               
                   
                 root.addChildTag(“requiredclass”,t); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
               
                   
                 TagGenerator createGroups(TagGenerator root, 
               
               
                   
                  String dir,String prevDir) 
               
             
          
           
               
                 { 
               
               
                 StringTokenizer tokDir = new 
               
               
                 StringTokenizer(dir,File.separator); 
               
               
                 boolean flag=false; 
               
               
                 if(dir.equals(prevDir)) 
               
             
          
           
               
                   
                 return root; 
               
             
          
           
               
                 else if(prevDir==null) 
               
               
                 { 
               
             
          
           
               
                   
                 while(tokDir.hasMoreTokens( )) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 String curr = tokDir.nextToken( ); 
               
               
                   
                 root = root.addChildTag(“group”,curr); 
               
               
                   
                 hash.put(curr,root); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 } 
               
               
                 else 
               
               
                 { 
               
             
          
           
               
                   
                 StringTokenizer tokPrev = new 
               
               
                   
                 StringTokenizer(prevDir,File.separator); 
               
               
                   
                 String prevRoot=null; 
               
               
                   
                 while(tokDir.hasMoreTokens( ) &amp;&amp; tokPrev.hasMoreTokens( )) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 String curr = tokDir.nextToken( ); 
               
               
                   
                 String prev = tokPrev.nextToken( ); 
               
               
                   
                 if((prevRoot==null) &amp;&amp; (!curr.equals(prev))) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 root=ancestor; 
               
               
                   
                 flag=true; 
               
             
          
           
               
                   
                 } 
               
               
                   
                 else if(!curr.equals(prev) &amp;&amp; !flag) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 flag=true; 
               
               
                   
                 root = (TagGenerator)hash.get(prevRoot); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 if(!curr.equals(prev) ∥ flag) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 flag=true; 
               
               
                   
                 root = root.addChildTag(“group”,curr); 
               
               
                   
                 hash.put(curr,root); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 prevRoot=prev; 
               
             
          
           
               
                   
                 } 
               
               
                   
                 while(tokDir.hasMoreTokens( )) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 String curr = tokDir.nextToken( ); 
               
               
                   
                 root = root.addChildTag(“group”,curr); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 } 
               
               
                 flag=false; 
               
               
                 return root; 
               
               
                 } 
               
               
                 String[ ] getTestCases(TestDescriptionWrapper td, File 
               
               
                 classDir,TagGenerator root) { 
               
               
                 String executeClassName = td.getParameter(“executeClass”); 
               
               
                 if (executeClassName == null) { 
               
               
                 System.err.println(td.getRootRelativePath( ) + 
               
               
                 “ is apparently a runtime test but does not have an 
               
               
                 executeClass specified.”); 
               
               
                 return null; 
               
               
                 } 
               
               
                 PathClassLoaderWrapper loader = new 
               
               
                 PathClassLoaderWrapper(classDir.getPath( )); 
               
               
                 try { 
               
             
          
           
               
                   
                 Class c = loader.loadClass(executeClassName); 
               
               
                   
                 if (isMultiTest(c, loader)) { 
               
               
                   
                 String[ ] args = 
               
               
                   
                  StringArrayWrapper.split(td.getParameter(“executeArgs”)); 
               
               
                   
                 for (int i = 0; i &lt; args.length; i++) { 
               
             
          
           
               
                   
                 if (args[i].equalsIgnoreCase(“-TestCaseID”)) { 
               
             
          
           
               
                   
                 // if -TestCaseID followed by ALL, drop out 
               
               
                   
                 // and determine all test cases; otherwise, 
               
               
                   
                 //get args up to next option (-*). 
               
               
                   
                 int first = ++i; 
               
               
                   
                 if (first &lt; args.length &amp;&amp; args[first].equals(“ALL”)) 
               
             
          
           
               
                   
                 break; 
               
             
          
           
               
                   
                 while (i &lt; args.length &amp;&amp; !args[i].startsWith(“-”)) 
               
             
          
           
               
                   
                 i++; 
               
               
                   
                 String[ ] testCases = new String[i − first]; 
               
               
                   
                 System.arraycopy(args, first, testCases, 0, 
               
               
                   
                  testCases.length); 
               
               
                   
                 return testCases; 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
               
                   
                 // no -TestCaseID found, or -TestCaseID ALL found 
               
               
                   
                 // go use reflection to determine the test cases 
               
               
                   
                 return getTestCases(c, loader); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 else 
               
               
                   
                 { 
               
             
          
           
               
                   
                 String[ ] cases = new String[1]; 
               
               
                   
                 cases[0]=“testcase1”; 
               
               
                   
                 return cases; 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 } 
               
               
                 catch (Exception e) { 
               
             
          
           
               
                   
                 e.getMessage( ); 
               
               
                   
                 e.printStackTrace( ); 
               
             
          
           
               
                 } 
               
               
                 return null; 
               
               
                 } 
               
               
                 private void setPackageName(TagGenerator tag, String path) 
               
               
                 { 
               
             
          
           
               
                   
                 tag.setAttribute(“package”,path.substring(1)); 
               
             
          
           
               
                 } 
               
               
                 } 
               
               
                   
               
             
          
         
       
     
         [0055]    
       
         
               
             
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
               
             
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
             
           
               
                   
               
               
                   
               
               
                 Listing 4 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 import com.sun.xtrf.generator.*; 
               
               
                 //this is XTRF API package - see Appendix 2 
               
               
                 import java.lang.reflect.Method; 
               
               
                 import java.io.*; 
               
               
                 import java.util.*; 
               
               
                 import java.net.*; 
               
               
                 public class TckGenerator 
               
               
                 { 
               
             
          
           
               
                   
                 public static void main(String[ ] args) { 
               
             
          
           
               
                   
                 TckGenerator gen = new TckGenerator( ); 
               
               
                   
                 gen.generate(args[0], args[1]); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 //directory that containes test sources 
               
               
                   
                 String sourceDir; 
               
               
                   
                 Map hash = new HashMap( ); 
               
               
                   
                 Map tmpHash =new HashMap( ) ; 
               
               
                   
                 TagGenerator ancestor; 
               
               
                   
                 String[ ] globalArgs; 
               
               
                   
                 /** 
               
               
                   
                  * creates components that read tck test suite files and 
               
             
          
           
               
                 perform generating 
               
             
          
           
               
                   
                  **/ 
               
             
          
           
               
                 public void generate(String outputDir,String inputDir) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                 XtrfGenerator gen = new 
               
               
                   
                 XtrfGenerator(outputDir); 
               
             
          
           
               
                 //part of the XTRF Generator API 
               
               
                 //it&#39;s used to start new xtrf document 
               
             
          
           
               
                   
                 TagGenerator root = 
               
             
          
           
               
                 gen.createRoot(“testsuite.xml”); 
               
               
                 //create root of the document - call the document 
               
               
                 //“testsuite.xml” 
               
             
          
           
               
                   
                  ancestor=root; 
               
               
                   
                  generateTree(root,inputDir); 
               
               
                   
                 gen.finishGenerating( ); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 /** 
               
               
                   
                  * generates the xtrf file that will be read by 
               
               
                   
                  * the framework 
               
               
                   
                 **/ 
               
               
                   
                 private void generateTree(TagGenerator root, 
               
               
                   
                  String inputDir) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 File testSuite = null; 
               
               
                   
                 String logFileName = null; 
               
               
                   
                 String outputFileName = “testsDescr.txt”; 
               
               
                   
                 int tfMode = 2; 
               
               
                   
                 boolean needTestCases = true; 
               
             
          
           
               
                   
                  File[ ] initialFiles = null; 
               
               
                   
                  String prevDir=null; 
               
               
                   
                  TagGenerator groupRoot=root; 
               
               
                   
                  Map map = new HashMap( ); 
               
               
                   
                  testSuite = new File (inputDir); 
               
             
          
           
               
                   
                 //This method takes all tests related info from the 
               
               
                   
                 //tck test suite and converts it to xtrf format 
               
             
          
           
               
                 File f = new File(testSuite, “..” + File.separator + “classes” 
               
               
                 + File.separator + “shared” + File.separator + 
               
               
                 “testClasses.lst”); 
               
               
                 FileInputStream stream = null; 
               
             
          
           
               
                   
                  try 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                  stream = new FileInputStream(f); 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                   
                  catch(Exception e) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                  e.getMessage( ); 
               
               
                   
                  e.printStackTrace( ); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 BufferedReader reader = new BufferedReader(new 
               
               
                 InputStreamReader(stream)); 
               
               
                  String line; 
               
               
                  try 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                 while((line = reader.readLine( ))!=null) 
               
               
                   
                 { 
               
               
                   
                  map.put(line.substring(0,line.indexOf 
               
             
          
           
               
                   
                 (“ ”)).trim( ),line.substring(line.indexOf 
               
               
                   
                 (“ ”)+1,line.length( )).trim( )); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                 catch(Exception e) 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                 e.getMessage( ); 
               
               
                   
                 e.printStackTrace( ); 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                  try 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                 testSuite = new File(inputDir); 
               
               
                   
                 testSuite = new File(testSuite.getCanonicalPath( )); 
               
               
                   
                 File testSuiteClasses = null; 
               
               
                   
                 if (needTestCases) { 
               
             
          
           
               
                   
                 if (testSuite.isDirectory( )) 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                 testSuiteClasses = new File(testSuite, “..” + 
               
             
          
           
               
                   
                  File.separator + “classes”); 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                   
                 else 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                  testSuiteClasses = new File (testSuite.getParent( ),“..” + 
               
               
                   
                  File.separator + “classes”); 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                   
                 if (!testSuiteClasses.exists( )) 
               
             
          
           
               
                   
                 } 
               
               
                   
                 TestFinderWrapper tf=null; 
               
               
                   
                 tf = new TestFinderWrapper( ); 
               
               
                   
                 tf.setMode(tfMode); 
               
               
                   
                 tf.setRoot(testSuite); 
               
               
                   
                 if (logFileName != null) { 
               
             
          
           
               
                   
                 log = new PrintWriter(new BufferedWriter 
               
             
          
           
               
                   
                 (new FileWriter(logFileName))); 
               
             
          
           
               
                   
                 tf.setVerify(true); 
               
             
          
           
               
                   
                 } 
               
               
                   
                 TestFinderQueueWrapper tfq = new TestFinderQueueWrapper( ); 
               
               
                   
                 tfq.setTestFinder(tf.getTestFinder( )); 
               
               
                   
                 tfq.setInitialFiles(testSuite, initialFiles); 
               
               
                   
                 TestDescriptionWrapper td; 
               
               
                   
                 while ((td = tfq.next( )) != null) { 
               
               
                   
                 String[ ] keywords = td.getKeywords( ); 
               
               
                   
                 String dir = 
               
             
          
           
               
                 td.getRootRelativePath( ).substring 
               
               
                 (0,td.getRootRelativePath( ).indexOf(td.getDir( ).getName( )) + 
               
               
                 td.getDir( ).getName( ).length( )); 
               
               
                 root = createGroups(groupRoot,dir,prevDir); 
               
               
                 groupRoot=root; 
               
               
                 prevDir =dir; 
               
               
                 if (needTestCases) { 
               
               
                 String executeClassName = 
               
             
          
           
               
                   
                  td.getParameter(“executeClass”); 
               
             
          
           
               
                 root = root.addChildTag 
               
             
          
           
               
                   
                 (“class”,executeClassName.substring 
               
               
                   
                 (executeClassName.lastIndexOf(“.”)+1, 
               
               
                   
                 executeClassName.length( ))); 
               
             
          
           
               
                 //add info to xtrf using the api 
               
               
                 if(executeClassName.indexOf(“.”)!=−1) 
               
               
                 root.setAttribute(“package”,executeClassName.substring 
               
             
          
           
               
                   
                 (0,executeClassName.lastIndexOf(“.”))); 
               
             
          
           
               
                 String[ ] testCases = getTestCases(td, testSuiteClasses,root); 
               
               
                 TagGenerator temp = null; 
               
               
                 if (testCases != null) { 
               
             
          
           
               
                   
                 for (int i = 0; i &lt; testCases.length; i++) { 
               
             
          
           
               
                   
                 if(!testCases[i].equals(“getStatus”)) 
               
               
                   
                 { 
               
             
          
           
               
                   
                 temp=root; 
               
               
                   
                 root = root.addChildTag(“testcase”, 
               
               
                   
                 testCases[i]); 
               
             
          
           
               
                   
                  createRequiredClasses(root,td.getRootRelativeURL( ),map); 
               
               
                   
                  addKeywords(root,keywords); 
               
               
                   
                  root=temp; 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                  } 
               
               
                 } 
               
               
                 } 
               
               
                  catch(Exception e) 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                 e.getMessage( ); 
               
               
                   
                 e.printStackTrace( ); 
               
             
          
           
               
                   
                  } 
               
               
                   
                 } 
               
             
          
           
               
                 private void addKeywords(TagGenerator root,String[ ] keywords) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                  if(keywords!=null) 
               
             
          
           
               
                   
                  { 
               
               
                   
                  for(int i=0; i &lt; keywords.length; i++) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                 root.addChildTag(“keyword”,keywords[i]); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 } 
               
               
                 private void createRequiredClasses(TagGenerator root, 
               
             
          
           
               
                   
                 String key,Map map) 
               
             
          
           
               
                 { 
               
               
                  if(map.containsKey(key)) 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                 String values = (String)map.get(key); 
               
               
                   
                 StringTokenizer tok = new StringTokenizer(values, “,”); 
               
               
                   
                 while(tok.hasMoreElements( )) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                  String 
                 t = tok.nextToken( ).trim( ); 
               
             
          
           
               
                   
                 root.addChildTag(“requiredclass”,t); 
               
             
          
           
               
                  } 
               
               
                 } 
               
               
                 TagGenerator createGroups(TagGenerator root, String dir, 
               
               
                  String prevDir) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                  StringTokenizer tokDir = new 
               
               
                 StringTokenizer(dir,File.separator); 
               
               
                  boolean flag=false; 
               
               
                  if(dir.equals(prevDir)) 
               
             
          
           
               
                   
                  return root; 
               
             
          
           
               
                  else if(prevDir==null) 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                 while(tokDir.hasMoreTokens( )) 
               
               
                   
                 { 
               
             
          
           
               
                   
                  String curr = tokDir.nextToken( ); 
               
               
                   
                  root = root.addChildTag(“group”,curr); 
               
               
                   
                  hash.put(curr,root); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                   
                 else 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                 StringTokenizer tokPrev = 
               
             
          
           
               
                   
                 new StringTokenizer(prevDir,File.separator); 
               
             
          
           
               
                   
                 String prevRoot=null; 
               
               
                   
                 while(tokDir.hasMoreTokens( ) &amp;&amp; tokPrev.hasMoreTokens( )) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                  String curr = tokDir.nextToken( ); 
               
               
                   
                  String prev = tokPrev.nextToken( ); 
               
               
                   
                  if((prevRoot==null) &amp;&amp; (!curr.equals(prev))) 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                 root=ancestor; 
               
               
                   
                 flag=true; 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                   
                  else if(!curr.equals(prev) &amp;&amp; !flag) 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                 flag=true; 
               
               
                   
                 root = (TagGenerator)hash.get(prevRoot); 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                   
                  if(!curr.equals(prev) ∥ flag) 
               
             
          
           
               
                   
                  { 
               
             
          
           
               
                   
                 flag=true; 
               
             
          
           
               
                 root = root.addChildTag(“group”,curr); 
               
             
          
           
               
                   
                 hash.put(curr,root); 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                   
                  prevRoot=prev; 
               
               
                   
                 } 
               
               
                   
                 while(tokDir.hasMoreTokens( )) 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                  String curr = tokDir.nextToken( ); 
               
               
                   
                  root = root.addChildTag(“group”,curr); 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                  } 
               
             
          
           
               
                  flag=false; 
               
               
                  return root; 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                 String[ ] getTestCases(TestDescriptionWrapper td, 
               
               
                  File classDir,TagGenerator root) { 
               
               
                 String executeClassName = td.getParameter(“executeClass”); 
               
               
                 if (executeClassName == null) { 
               
             
          
           
               
                   
                  System.err.println(td.getRootRelativePath( ) + 
               
             
          
           
               
                  “ is apparently a runtime test but does not have an 
               
             
          
           
               
                   
                  executeClass specified.”); 
               
             
          
           
               
                 return null; 
               
               
                 } 
               
               
                 PathClassLoaderWrapper loader = 
               
               
                  new PathClassLoaderWrapper(classDir.getPath( )); 
               
               
                  try { 
               
             
          
           
               
                   
                  Class c = loader.loadClass(executeClassName); 
               
               
                   
                  if (isMultiTest(c, loader)) { 
               
             
          
           
               
                   
                 String[ ] args = 
               
             
          
           
               
                 StringArrayWrapper.split(td.getParameter(“executeArgs”)); 
               
             
          
           
               
                   
                 for (int i = 0; i &lt; args.length; i++) { 
               
             
          
           
               
                   
                 if (args[i].equalsIgnoreCase(“-TestCaseID”)) { 
               
             
          
           
               
                   
                  // if -TestCaseID followed by ALL, drop out and determine 
               
               
                   
                  // alltest cases; 
               
               
                   
                  // otherwise, get args up to next option (-*). 
               
               
                   
                  int first = ++i; 
               
               
                   
                  if (first &lt; args.length &amp;&amp; args[first].equals(“ALL”)) 
               
             
          
           
               
                   
                  break; 
               
             
          
           
               
                   
                  while (i &lt; args.length &amp;&amp; !args[i].startsWith(“-”)) 
               
             
          
           
               
                   
                  i++; 
               
             
          
           
               
                   
                  String[ ] testCases = new String [i - first]; 
               
               
                   
                  System.arraycopy(args, first, testCases, 0, 
               
             
          
           
               
                   
                 testCases.length); 
               
             
          
           
               
                   
                  return testCases; 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                   
                 } 
               
               
                   
                 // no -TestCaseID found, or -TestCaseID ALL found 
               
               
                   
                 // go use reflection to determine the test cases 
               
               
                   
                 return getTestCases(c, loader); 
               
             
          
           
               
                   
                  } 
               
               
                   
                  else 
               
             
          
           
               
                   
                 { 
               
             
          
           
               
                   
                 String[ ] cases = new String[1]; 
               
               
                   
                 cases[0]=“testcase1”; 
               
               
                   
                 return cases; 
               
             
          
           
               
                   
                 } 
               
             
          
           
               
                  } 
               
               
                  catch (Exception e) { 
               
             
          
           
               
                   
                  e.getMessage( ); 
               
               
                   
                  e.printStackTrace( ); 
               
             
          
           
               
                  } 
               
               
                  return null; 
               
               
                  } 
               
               
                 private void setPackageName(TagGenerator tag, 
               
               
                  String path) 
               
             
          
           
               
                   
                 { 
               
               
                   
                  tag.setAttribute(“package”,path.substring(1)); 
               
               
                   
                 } 
               
             
          
           
               
                 } 
               
               
                   
               
             
          
         
       
     
       Appendix 1  
       [0000]     XTRF Generator  
         [0000]     Description  
         [0056]     This document is generated from sample source code and HTML files with examples of a wide variety of Java language constructs: packages, subclasses, subinterfaces, nested classes, nested interfaces, inheriting from other packages, constructors, fields, methods, and so forth.  
         [0057]     Here is an example of the tag “@link com.package.SubClass#publicStaticMethod( )” (shown without curly braces) in a sentence: {@link com.package.SubClass#publicStaticMethod( )}. Note that the reference must be fully qualified when inside an overview file. Any label (the second argument in @link) would be ignored by the MIF Doclet.  
         [0058]     Here is an image:  
         [0059]     H2 Heading  
         [0060]     This is text below the H2 heading.  
         [0061]     H3 Heading  
         [0062]     This is text below the H3 heading.  
         [0063]     H4 Heading  
         [0064]     This is text below the H4 heading.  
         [0065]     H5 Heading  
         [0066]     This is text below the H5 heading.  
         [0067]     H6 Heading  
         [0068]     This is text below the H6 heading.  
         [0069]     The following is a sample table.  
                                                       first item   This is the description of the first item.               It is long enough to wrap to the next line.           Second Item   This is the description of the second item.               It is long enough to wrap to the next line.           last Item   This is the description of the last item.               It is long enough to wrap to the next line.                      
 
         [0070]     Package Summary  
         [0071]     Package com.sun.xtrf.generator  
         [0072]     Class Summary  
         [0073]     Classes  
         [0074]     TagGenerator: This class provides user with ability to create xml tag with any given name and attributes.  
         [0075]     TagLinkedGenerator Title: xtrfGenerator Description: This package is an API for generating xtrf formatted files.  
         [0076]     XtrfGenerator: This class provides an engine for xml document generating.  
         [0077]     TagGenerator com.sun.xtrf.generator  
         [0078]     TagGenerator( )  
         [0079]     com.sun.xtrf.generator  
         [0080]     TagGenerator  
         [0081]     Declaration  
         [0082]     public class TagGenerator  
         [0083]     java.lang.Object  
         [0084]     +--com.sun.xtrf.generator.TagGenerator  
         [0085]     Direct Known Subclasses: TagLinkedGenerator  
         [0086]     Description  
         [0087]     This class provides user with ability to create xml tag with any given name and attributes.  
         [0088]     Member Summary  
         [0089]     Constructors  
         [0090]     TagGenerator( )  
         [0091]     TagGenerator(Element el, Document doc)  
         [0092]     Methods  
         [0093]     TagGenerator addChildTag(java.lang.String tag)  
         [0094]     This method allows to add child tag to this tag.  
         [0095]     TagGenerator addChildTag(java.lang.String tag, java.lang.String name)  
         [0096]     This method allows to add child tag to this tag.  
         [0097]     void setAttribute(java.lang.String key, java.lang.String value)  
         [0098]     This method allows to set attributes to this tag.  
         [0099]     void setText(java.lang.String text)  
         [0100]     This method allows to add text node to this tag.  
         [0101]     Inherited Member Summary  
         [0102]     Methods inherited from class Object:  
         [0103]     clone( ), equals(Object), finalize( ), getClass( ), hashCode( ), notify( ), notifyAll( ),  
         [0104]     toString( ), wait( ), wait( ), wait( )  
         [0105]     Constructors  
         [0106]     TagGenerator( )  
         [0107]     public TagGenerator( )  
         [0108]     TagGenerator(Element, Document)  
         [0109]     public TagGenerator(com.sun.xtrf.generator.Element el, com.sun.xtrf.generator.Document doc)  
         [0110]     Parameters:  
         [0111]     el—current node in the DOM tree  
         [0112]     doc—current document  
         [0113]     Methods  
         [0114]     addChildTag(String)  
         [0115]     public com.sun.xtrf.generator.TagGenerator  
         [0116]     addChildTag(java.lang.String tag)  
         [0117]     This method allows to add child tag to this tag.  
         [0118]     Parameters:  
         [0119]     tag—name of the tag  
         [0120]     Returns: the object that represents child tag  
         [0121]     addChildTag(String, String)  
         [0122]     public com.sun.xtrf.generator.TagGenerator  
         [0123]     addChildTag(java.lang.String tag,java.lang.String name)  
         [0124]     This method allows to add child tag to this tag.  
         [0125]     Parameters:  
         [0126]     tag—name of the tag  
         [0127]     name—value of the name attribute  
         [0128]     Returns: the object that represents child tag  
         [0129]     setAttribute(String, String)  
         [0130]     public void setAttribute(java.lang.String key, java.lang.String value)  
         [0131]     This method allows to set attributes to this tag.  
         [0132]     setText(String)  
         [0133]     public void setText(java.lang.String text)  
         [0134]     This method allows to add text node to this tag.  
         [0135]     com.sun.xtrf.generator  
         [0136]     TagLinkedGenerator  
         [0137]     Declaration  
         [0138]     public class TagLinkedGenerator extends TagGenerator  
         [0139]     java.lang.Object  
         [0140]     +--com.sun.xtrf.generator.TagGenerator  
         [0141]     +--com.sun.xtrf.generator.TagLinkedGenerator  
         [0142]     Description  
         [0143]     Title: xtrfGenerator Description: This package is an API for generating xtrf formatted files. It provides classes for tag and attributes generating, and engine that creates files from generated tags Copyright: Copyright (c) 2001  
         [0144]     Company: Sun Microsystems  
         [0145]     Member Summary  
         [0146]     Constructors  
         [0147]     TagLinkedGenerator( )  
         [0148]     TagLinkedGenerator(Element el, XmlDocument doc)  
         [0149]     Methods  
         [0150]     TagGenerator addChildTag(java.lang.String tag)  
         [0151]     This method allows to add child tag to this tag.  
         [0152]     TagGenerator addChildTag(java.lang.String tag, java.lang.String name)  
         [0153]     Inherited Member Summary  
         [0154]     Methods inherited from class Object  
         [0155]     clone( ), equals(Object), finalize( ), getClass( ), hashCode( ), notify( ), notifyAll( ),  
         [0156]     toString( ), wait( ), wait( ), wait( )  
         [0157]     Methods inherited from class TagGenerator  
         [0158]     setAttribute(String, String), setText(String)  
         [0159]     Constructors  
         [0160]     TagLinkedGenerator( )  
         [0161]     public TagLinkedGenerator( )  
         [0162]     TagLinkedGenerator(Element, XmlDocument)  
         [0163]     public TagLinkedGenerator(com.sun.xtrf.generator.Element el, com.sun.xtrf.generator.XmlDocument doc)  
         [0164]     Methods  
         [0165]     addChildTag(String)  
         [0166]     public com.sun.xtrf.generator.TagGenerator  
         [0167]     addChildTag(java.lang.String tag)  
         [0168]     this method allows to add child tag to this tag  
         [0169]     Overrides: addChildTag in class TagGenerator  
         [0170]     Returns: the object that represents child tag  
         [0171]     addChildTag(String, String)  
         [0172]     public com.sun.xtrf.generator.TagGenerator  
         [0173]     addChildTag(java.lang.String tag, java.lang.String name)  
         [0174]     Description copied from class:  
         [0175]     com.sun.xtrf.generator.TagGenerator  
         [0176]     This method allows to add child tag to this tag.  
         [0177]     Overrides: addChildTag in class TagGenerator  
         [0178]     XtrfGenerator  
         [0179]     Declaration  
         [0180]     public class XtrfGenerator  
         [0181]     java.lang.Object  
         [0182]     +--com.sun.xtrf.generator.XtrfGenerator  
         [0183]     Description:  
         [0184]     This class provides an engine for xml document generating.  
         [0185]     Constructors  
         [0186]     XtrfGenerator(String)  
         [0187]     public XtrfGenerator(java.lang.String outputPath)  
         [0188]     Parameters:  
         [0189]     outputpath—directory that will contain generated files  
         [0190]     Member Summary  
         [0191]     Constructors  
         [0192]     XtrfGenerator(java.lang.String outputpath)  
         [0193]     Methods  
         [0194]     TagGenerator createRoot(java.lang.String fileName)  
         [0195]     This method creates tag that represents root of the xtrf  
         [0196]     document from given name of the tag.  
         [0197]     void finishGenerating( )  
         [0198]     This method should be called in order to finish generation of the xtrf files.  
         [0199]     static  
         [0200]     java.lang.String  
         [0201]     getOutputPath( )  
         [0202]     Inherited Member Summary  
         [0203]     Methods inherited from class Object  
         [0204]     clone( ), equals(Object), finalize( ), getClass( ), hashcode( ), notify( ), notifyAll( ),  
         [0205]     toString( ), wait( ), wait( ), wait( )  
         [0206]     com.sun.xtrf.generator XtrfGenerator  
         [0207]     createRoot(String)  
         [0208]     Methods  
         [0209]     createRoot(String)  
         [0210]     public com.sun.xtrf.generator.TagGenerator  
         [0211]     createRoot(java.lang.String fileName).  
         [0212]     This method creates tag that represents root of the xtrf document from given name of the tag.  
         [0213]     Returns: TagGenerator object that represents this tag&#39;s node in the tree  
         [0214]     finishGenerating( )  
         [0215]     public void finishGenerating( )  
         [0216]     This method should be called in order to finish generating of the xtrf files.  
         [0217]     getOutputPath( )  
         [0218]     public static java.lang.String getOutputPath( )  
         [0219]     Returns: directory for files storage  
         [0220]     XtrfGenerator com.sun.xtrf.generator  
         [0221]     getOutputPath( )  
       Appendix 2  
       [0222]     Description  
         [0223]     This document is generated from sample source code and HTML files with examples of a wide variety of Java language constructs: packages, subclasses, subinterfaces, nested classes, nested interfaces, inheriting from other packages, constructors, fields, methods, and so forth.  
         [0224]     XTRF Parser  
         [0225]     com.sun.xtrf.parser  
         [0226]     Package Summary  
         [0227]     Package  
         [0228]     com.sun.xtrf.parser  
         [0229]     Class Summary  
         [0230]     Interfaces  
         [0231]     TagHandler This is an interface for all xtrf tag handlers that will be implemented it processes tag information and attributes for further usage.  
         [0232]     Classes  
         [0233]     Group: This class represents group entity which is a node on the package tree.  
         [0234]     KeywordsHandler: This class handles a requiredclass tag that also represents test group.  
         [0235]     LinkHandler: This class handles a link tag in xtrf format.  
         [0236]     PropertiesHandler: This class handles a requiredclass tag that also represents test group.  
         [0237]     RequiredClassHandler: This class handles requiredclass tag that also represents a test group.  
         [0238]     SourceHandler: This class handles a source tag in a xtrf document.  
         [0239]     TestCase: TestCase objects embody the name of the test case and the information about this test case. The list of the objects is extracted from XTRF format files by the appropriate XML parser (files that contain all necessary information about test parameters and execution in XML format).  
         [0240]     TestClass: TestClass objects embody the name of the class and the required information about the test class. The list of the objects is extracted from XTRF format files by the appropriate XML parser(files that contain all necessary information about test parameters and execution in XML format).  
         [0241]     TestGroup: This abstract class represents an abstract entity which is one of TestSuite, TestPackage, TestClass or TestCase. It provides information about the children of this TestGroup and value of the name attribute. It also provides a client programmer with the ability to add its own tag to the format and class that handles this tag (This class should implement the TagHandler interface).  
         [0242]     TestPackage. The TestPackage object embodies the name of the testpackage and needed information. The list of the objects is extracted from XTRF format files by the appropriate XML parser (files that contain all necessary information about test parameters and execution in XML format).  
         [0243]     TestSuite: TestSuite objects embody the name of the testsuite and information about their children. The list of the objects is extracted from XTRF format files by the appropriate XML parser(files that contain all necessary information about test parameters and execution in XML format).  
         [0244]     XtrfApi This is an API class for the XTRF parser that contains methods that allow user to use this parser as a stand-alone application.  
         [0245]     Group  
         [0246]     Declaration  
         [0247]     public class Group extends TestGroup  
         [0248]     java.lang.Object  
         [0249]     +--com.sun.xtrf.parser.TestGroup  
         [0250]     +--com.sun.xtrf.parser.Group  
         [0251]     Description  
         [0252]     This class represents group entity which is a node on the package tree.  
         [0253]     Inherited Member Summary  
         [0254]     Fields inherited from class TestGroup  
         [0255]     attributesMap, el, keywords, parser  
         [0256]     Methods inherited from class Object  
         [0257]     clone( ), equals(Object), finalize( ), getClass( ), hashCode( ), notify( ), notifyAll( ), toString( ), wait( ), wait( ), wait( )  
         [0258]     Methods inherited from class TestGroup  
         [0259]     addTagHandler(String, TagHandler), getChildren( ), getKeywords( ), getName( ), getProperties( ), getRequiredClasses( ), getSource( )  
         [0260]     KeywordsHandler  
         [0261]     Declaration  
         [0262]     public class KeywordsHandler extends TestGroup implements  
         [0263]     TagHandler  
         [0264]     java.lang.Object  
         [0265]     +--com.sun.xtrf.parser.TestGroup  
         [0266]     +--com.sun.xtrf.parser.KeywordsHandler  
         [0267]     All Implemented Interfaces: TagHandler  
         [0268]     Description  
         [0269]     THis class handles a requiredclass tag that also represents a test group.  
         [0270]     Member Summary  
         [0271]     Constructors  
         [0272]     KeywordsHandler( )  
         [0273]     Methods  
         [0274]     void handleTag(TestGroup group, org.w3c.dom.Node node)  
         [0275]     This method handles requredclass tag and its children.  
         [0276]     Inherited Member Summary  
         [0277]     Fields inherited from class TestGroup  
         [0278]     attributesMap, el, keywords, parser  
         [0279]     Methods inherited from class Object  
         [0280]     clone( ), equals(Object), finalize( ), getClass( ), hashcode( ), notify( ), notifyAll( ), toString( ), wait( ), wait( ), wait( )  
         [0281]     Methods inherited from class TestGroup  
         [0282]     addTagHandler(String, TagHandler), getChildren( ), getKeywords( ), getName( ), getProperties( ), getRequiredClasses( ), getSource( )  
         [0283]     Constructors  
         [0284]     KeywordsHandler( )  
         [0285]     public KeywordsHandler( )  
         [0286]     Methods  
         [0287]     handleTag(TestGroup, Node)  
         [0288]     public void handleTag(com.sun.xtrf.parser.TestGroup group, org.w3c.dom.Node node)  
         [0289]     This method handles requredclass tag and its children.  
         [0290]     Specified By: handleTag in interface TagHandler  
         [0291]     LinkHandler  
         [0292]     Declaration  
         [0293]     public class LinkHandler implements TagHandler  
         [0294]     java.lang.Object  
         [0295]     +--com.sun.xtrf.parser.LinkHandler  
         [0296]     All Implemented Interfaces: TagHandler  
         [0297]     Description  
         [0298]     This class handles link tag in xtrf format  
         [0299]     Constructors  
         [0300]     LinkHandler( )  
         [0301]     public LinkHandler( )  
         [0302]     Methods  
         [0303]     handleTag(TestGroup, Node)  
         [0304]     public void handleTag(com.sun.xtrf.parser.TestGroup group, org.w3c.dom.Node node)  
         [0305]     Member Summary  
         [0306]     Constructors  
         [0307]     LinkHandler( )  
         [0308]     Methods  
         [0309]     void handleTag(TestGroup group, org.w3c.dom.Node node)  
         [0310]     This method handles link tag.  
         [0311]     Inherited Member Summary  
         [0312]     Methods inherited from class Object  
         [0313]     clone( ), equals(Object), finalize( ), getClass( ), hashCode( ), notify( ), notifyAll( ), toString( ), wait( ), wait( ), wait( )  
         [0314]     LinkHandler com.sun.xtrf.parser  
         [0315]     handleTag(TestGroup, Node)  
         [0316]     This method handles link tag  
         [0317]     Specified By: handleTag in interface TagHandler  
         [0318]     PropertiesHandler  
         [0319]     Declaration  
         [0320]     public class PropertiesHandler extends TestGroup implements  
         [0321]     TagHandler  
         [0322]     java.lang.Object  
         [0323]     +--com.sun.xtrf.parser.TestGroup  
         [0324]     +--com.sun.xtrf.parser.PropertiesHandler  
         [0325]     All Implemented Interfaces: TagHandler  
         [0326]     Description  
         [0327]     This class handles requredclass tag that also represents test group.  
         [0328]     Member Summary  
         [0329]     Constructors  
         [0330]     PropertiesHandler( )  
         [0331]     Methods  
         [0332]     void handleTag(TestGroup group, org.w3c.dom.Node node)  
         [0333]     This method handles requiredclass tag and its children.  
         [0334]     Inherited Member Summary  
         [0335]     Fields inherited from class TestGroup  
         [0336]     attributesMap, el, keywords, parser  
         [0337]     Methods inherited from class Object  
         [0338]     clone( ), equals(Object), finalize( ), getClass( ), hashCode( ), notify( ), notifyAll( ), toString( ), wait( ), wait( ), wait( )  
         [0339]     Methods inherited from class TestGroup  
         [0340]     addTagHandler(String, TagHandler), getChildren( ), getKeywords( ), getName( ), getProperties( ), getRequiredClasses( ), getSource( )  
         [0341]     Constructors  
         [0342]     PropertiesHandler( )  
         [0343]     public PropertiesHandler( )  
         [0344]     Methods  
         [0345]     handleTag(TestGroup, Node)  
         [0346]     public void handleTag(com.sun.xtrf.parser.TestGroup group, org.w3c.dom.Node node)  
         [0347]     This method handles requiredclass tag and its children.  
         [0348]     Specified By: handleTag in interface TagHandler  
         [0349]     RequiredClassHandler  
         [0350]     Declaration  
         [0351]     public class RequiredClassHandler extends TestGroup implements  
         [0352]     TagHandler  
         [0353]     java.lang.Object  
         [0354]     +--com.sun.xtrf.parser.TestGroup  
         [0355]     +--com.sun.xtrf.parser.RequiredClassHandler  
         [0356]     All Implemented Interfaces: TagHandler  
         [0357]     Description  
         [0358]     This class handles requiredclass tag that also represents a test group.  
         [0359]     Member Summary  
         [0360]     Constructors  
         [0361]     RequiredClassHandler( )  
         [0362]     Methods  
         [0363]     void handleTag(TestGroup group, org.w3c.dom.Node node)  
         [0364]     This method handles requredclass tag and its children.  
         [0365]     Inherited Member Summary  
         [0366]     Fields inherited from class TestGroup  
         [0367]     attributesMap, el, keywords, parser  
         [0368]     Methods inherited from class Object  
         [0369]     clone( ), equals(Object), finalize( ), getClass( ), hashCode( ), notify( ), notifyAll( ), toString( ), wait( ), wait( ), wait( )  
         [0370]     Methods inherited from class TestGroup  
         [0371]     addTagHandler(String, TagHandler), getChildren( ), getKeywords( ), getName( ), getProperties( ), getRequiredClasses( ), getSource( )  
         [0372]     Constructors  
         [0373]     RequiredClassHandler( )  
         [0374]     public RequiredClassHandler( )  
         [0375]     Methods  
         [0376]     handleTag(TestGroup, Node)  
         [0377]     public void handleTag(com.sun.xtrf.parser.TestGroup group, org.w3c.dom.Node node)  
         [0378]     This method handles requredclass tag and its children.  
         [0379]     Specified By: handleTag in interface TagHandler  
         [0380]     SourceHandler  
         [0381]     Declaration  
         [0382]     public class SourceHandler implements TagHandler  
         [0383]     java.lang.Object  
         [0384]     +--com.sun.xtrf.parser.SourceHandler  
         [0385]     All Implemented Interfaces: TagHandler  
         [0386]     Description  
         [0387]     This class handles source tag in xtrf document  
         [0388]     Constructors  
         [0389]     SourceHandler( )  
         [0390]     public SourceHandler( )  
         [0391]     Methods  
         [0392]     handleTag(TestGroup, Node)  
         [0393]     public void handleTag(com.sun.xtrf.parser.TestGroup group, org.w3c.dom.Node node)  
         [0394]     Member Summary  
         [0395]     Constructors  
         [0396]     SourceHandler( )  
         [0397]     Methods  
         [0398]     void handleTag(TestGroup group, org.w3c.dom.Node node)  
         [0399]     This method handles source tag.  
         [0400]     Inherited Member Summary  
         [0401]     Methods inherited from class Object  
         [0402]     clone( ), equals(Object), finalize( ), getClass( ), hashCode( ), notify( ), notifyAll( ),toString( ), wait( ), wait( ), wait( )  
         [0403]     Constructors  
         [0404]     SourceHandler( )  
         [0405]     public SourceHandler( )  
         [0406]     Methods  
         [0407]     handleTag(TestGroup, Node)  
         [0408]     public void handleTag(com.sun.xtrf.parser.TestGroup group, org.w3c.dom.Node node)  
         [0409]     This method handles source tag.  
         [0410]     Specified By: handleTag in interface TagHandler.  
         [0411]     TagHandler  
         [0412]     Declaration  
         [0413]     public interface TagHandler  
         [0414]     All Known Implementing Classes: KeywordsHandler, LinkHandler, SourceHandler, PropertiesHandler, RequiredClassHandler  
         [0415]     Description  
         [0416]     This is an interface for all xtrf tag handlers that will be implemented it processes tag information and attributes for further usage.  
         [0417]     Methods  
         [0418]     handleTag(TestGroup, Node)  
         [0419]     public void handleTag(com.sun.xtrf.parser.TestGroup group, org.w3c.dom.Node node)  
         [0420]     Parameters:  
         [0421]     group—test group to which this tag belongs  
         [0422]     node—node that represents this tag  
         [0423]     Member Summary  
         [0424]     Methods  
         [0425]     void handleTag(TestGroup group, org.w3c.dom.Node node)  
         [0426]     TestCase  
         [0427]     Declaration  
         [0428]     public class TestCase extends TestGroup  
         [0429]     java.lang.Object  
         [0430]     +--com.sun.xtrf.parser.TestGroup  
         [0431]     +--com.sun.xtrf.parser.TestCase  
         [0432]     Description  
         [0433]     TestCase objecta embody the name of the test case and the information about this test case. The list of the objects is extracted from XTRF format files by the appropriate XML parser(files that contain all necessary information about test parameters and execution in XML format).  
         [0434]     Member Summary  
         [0435]     Methods java.lang.String getJavaName( )  
         [0436]     Gets java name of this test case that consists from package name+class name+test case name.  
         [0437]     java.util.Properties getProperties( )  
         [0438]     Inherited Member Summary  
         [0439]     Fields inherited from class TestGroup  
         [0440]     attributesMap, el, keywords, parser  
         [0441]     Methods inherited from class Object  
         [0442]     clone( ), equals(Object), finalize( ), getClass( ), hashcode( ), notify( ), notifyAll( ), toString( ), wait( ), wait( ), wait( )  
         [0443]     Methods inherited from class TestGroup  
         [0444]     addTagHandler(String, TagHandler), getChildren( ), getKeywords( ), getName( ), getRequiredClasses( ), getSource( )  
         [0445]     Methods  
         [0446]     getJavaName( )  
         [0447]     public java.lang.String getJavaName( )  
         [0448]     Gets java name of this test case that consists from package  
         [0449]     name+class name+test case name.  
         [0450]     getProperties( )  
         [0451]     public java.util.Properties getProperties( )  
         [0452]     Description copied from class: com.sun.xtrf.parser.TestGroup  
         [0453]     This method returns this group&#39;s properties as they appear in XTRF.  
         [0454]     Overrides: getProperties in class TestGroup  
         [0455]     TestClass  
         [0456]     Declaration  
         [0457]     public class TestClass extends TestGroup  
         [0458]     java.lang.Object  
         [0459]     +--com.sun.xtrf.parser.TestGroup  
         [0460]     +--com.sun.xtrf.parser.TestClass  
         [0461]     Description  
         [0462]     TestClass objects embody the name of the class and the required information about the test class. The list of the objects is extracted from XTRF format files by the appropriate XML parser(files that contain all necessary information about test parameters and execution in XML format).  
         [0463]     Inherited Member Summary  
         [0464]     Fields inherited from class TestGroup  
         [0465]     attributesMap, el, keywords, parser  
         [0466]     Methods inherited from class Object  
         [0467]     clone( ), equals(Object), finalize( ), getClass( ), hashCode( ), notify( ), notifyAll( ), toString( ), wait( ), wait( ), wait( )  
         [0468]     Methods inherited from class TestGroup  
         [0469]     addTagHandler(String, TagHandler), getChildren( ), getKeywords( ), getName( ), getProperties( ), getRequiredClasses( ), getSource( )  
         [0470]     TestGroup  
         [0471]     Declaration  
         [0472]     public abstract class TestGroup  
         [0473]     java.lang.Object  
         [0474]     +--com.sun.xtrf.parser.TestGroup  
         [0475]     Direct Known Subclasses: Group, KeywordsHandler,  
         [0476]     PropertiesHandler, RequiredClassHandler, TestCase, TestClass, TestPackage, TestSuite  
         [0477]     Description  
         [0478]     This abstract class represents an abstract entity which is either TestSuite, TestPackage,.TestClass or TestCase. It provides information about the children of this TestGroup and value of the name attribute. It also provides a client programmer with the ability to add its own tag to the format and class that handles this tag (This class should implement TagHandler interface)  
         [0479]     Member Summary  
         [0480]     Fields  
         [0481]     protected  
         [0482]     java.util.Map  
         [0483]     attributesmap  
         [0484]     protected Element el  
         [0485]     current node in the parsed tree  
         [0486]     protected java.util.LinkedList  
         [0487]     keywords  
         [0488]     protected XTRFParser parser  
         [0489]     Instance of the class that handles parsing.  
         [0490]     Constructors  
         [0491]     TestGroup( )  
         [0492]     Methods  
         [0493]     void addTagHandler(java.lang.String tagName, TagHandler handler)  
         [0494]     Allows adding xml tag and class that handles it to the parser.  
         [0495]     TestGroup[] getChildren( )  
         [0496]     Get the list of the children of this group may consists of different groups.  
         [0497]     java.util.LinkedList getKeywords( )  
         [0498]     java.lang.String getName( )  
         [0499]     Get value of the name attribute.  
         [0500]     java.util.Properties getProperties( )  
         [0501]     This method returns this group&#39;s properties as they appear in XTRF.  
         [0502]     java.util.Map getRequiredClasses( )  
         [0503]     this method returns map that containes pairs of the form:  
         [0504]     requiredclass name—its source.  
         [0505]     java.lang.String getSource( )  
         [0506]     This method returns source of this test group.  
         [0507]     Inherited Member Summary  
         [0508]     Methods inherited from class Object  
         [0509]     clone( ), equals(Object), finalize( ), getClass( ), hashCode( ), notify( ), notifyAll( ),toString( ), wait( ), wait( ), wait( )  
         [0510]     Fields  
         [0511]     attributesMap  
         [0512]     protected java.util.Map attributesMap  
         [0513]     el  
         [0514]     protected com.sun.xtrf.parser.Element el  
         [0515]     Current node in the parsed tree.  
         [0516]     Keywords  
         [0517]     protected java.util.LinkedList keywords  
         [0518]     parser  
         [0519]     protected com.sun.xtrf.parser.XTRFParser parser  
         [0520]     instance of the class that handles parsing  
         [0521]     Constructors  
         [0522]     TestGroup( )  
         [0523]     public TestGroup( )  
         [0524]     Methods  
         [0525]     addTagHandler(String, TagHandler)  
         [0526]     public void addTagHandler(java.lang.String tagName, com.sun.xtrf.parser.TagHandler handler)  
         [0527]     allows adding xml tag and class that handles it to the parser getChildren( )  
         [0528]     public com.sun.xtrf.parser.TestGroup[] getChildren( )  
         [0529]     Get the list of the children of this group may consists of different groups  
         [0530]     getKeywords( )  
         [0531]     public java.util.LinkedList getKeywords( )  
         [0532]     getName( )  
         [0533]     public java.lang.String getName( )  
         [0534]     get value of the name attribute  
         [0535]     getProperties( )  
         [0536]     public java.util.Properties getProperties( )  
         [0537]     This method returns this group&#39;s properties as they appear in XTRF.  
         [0538]     Returns: properties of this test group. If there are no properties returns null.  
         [0539]     getRequiredClasses( )  
         [0540]     public java.util.Map getRequiredClasses( )  
         [0541]     This method returns map that containes pairs of the form:  
         [0542]     requiredclass name its source  
         [0543]     getSource( )  
         [0544]     public java.lang.String getSource( )  
         [0545]     This method returns source of this test group.  
         [0546]     Returns: source of this group null if there is no source  
         [0547]     TestPackage  
         [0548]     Declaration  
         [0549]     public class TestPackage extends TestGroup  
         [0550]     java.lang.Object  
         [0551]     +--com.sun.xtrf.parser.TestGroup  
         [0552]     +--com.sun.xtrf.parser.TestPackage  
         [0553]     Description  
         [0554]     TestPackage object embodies the name of the testpackage and needed information The list of the objects is extracted from XTRF format files by the appropriate XML parser(files that contain all necessary information about test parameters and execution in XML format).  
         [0555]     Inherited Member Summary  
         [0556]     Fields inherited from class TestGroup  
         [0557]     attributesMap, el, keywords, parser  
         [0558]     Methods inherited from class Object.  
         [0559]     clone( ), equals(Object), finalize( ), getClass( ), hashcode( ), notify( ), notifyAll( ), toString( ), wait( ), wait( ), wait( )  
         [0560]     Methods inherited from class TestGroup  
         [0561]     addTagHandler(String, TagHandler), getChildren( ), getKeywords( ), getName( ), getProperties( ), getRequiredClasses( ), getSource( )  
         [0562]     TestSuite  
         [0563]     Declaration  
         [0564]     public class TestSuite extends TestGroup  
         [0565]     java.lang.Object  
         [0566]     +--com.sun.xtrf.parser.TestGroup  
         [0567]     +--com.sun.xtrf.parser.TestSuite  
         [0568]     Description  
         [0569]     TestSuite object embody the name of the testsuite and information about its children The list of the objects is extracted from XTRF format files by the appropriate XML parser(files that contain all necessary information about test parameters and execution in XML format).  
         [0570]     Inherited Member Summary  
         [0571]     Fields inherited from class TestGroup  
         [0572]     attributesMap, el, keywords, parser  
         [0573]     Methods inherited from class Object  
         [0574]     clone( ), equals(Object), finalize( ), getClass( ), hashCode( ), notify( ), notifyAll( ), toString( ), wait( ), wait( ), wait( )  
         [0575]     Methods inherited from class TestGroup  
         [0576]     addTagHandler(String, TagHandler), getChildren( ), getKeywords( ), getName( ), getProperties( ), getRequiredClasses( ), getSource( )  
         [0577]     XtrfApi  
         [0578]     Declaration  
         [0579]     public class XtrfApi  
         [0580]     java.lang.Object  
         [0581]     +--com.sun.xtrf.parser.XtrfApi  
         [0582]     Description  
         [0583]     This is an api class for xtrf parser contains methods that allow user to use this parser as a stand-alone application.  
         [0584]     Member Summary  
         [0585]     Constructors  
         [0586]     XtrfApi( )  
         [0587]     Methods  
         [0588]     static  
         [0589]     java.lang.String  
         [0590]     getLocation( )  
         [0591]     TestGroup getRoot(java.io.File file)  
         [0592]     get root element of xtrf file  
         [0593]     void init( )  
         [0594]     load tag and attributes handlers  
         [0595]     void setLocation(java.lang.String location)  
         [0596]     sets physical location of xtrf format files  
         [0597]     Inherited Member Summary  
         [0598]     Methods inherited from class Object  
         [0599]     clone( ), equals(Object), finalize( ), getClass( ), hashCode( ), notify( ), notifyAll( ), toString( ), wait( ), wait( ), wait( )  
         [0600]     Constructors  
         [0601]     XtrfApi( )  
         [0602]     public XtrfApi( )  
         [0603]     Methods  
         [0604]     getLocation( )  
         [0605]     public static java.lang.String getLocation( )  
         [0606]     getRoot(File)  
         [0607]     public com.sun.xtrf.parser.TestGroup getRoot(java.io.File file)  
         [0608]     get root element of xtrf file  
         [0609]     init( )  
         [0610]     public void init( )  
         [0611]     load tag and attributes handlers  
         [0612]     setLocation(String)  
         [0613]     public void setLocation(java.lang.String location)  
         [0614]     sets physical location of xtrf format files