This directory contains tests for ROSE.  

The tests are divided into separate directories to test the ability to
compile code and the ability to execute the compiled code separately. Other
tests isolate parts of the internal ROSE infrastructure for testing that
use to be in the ROSE/src directory but could not be colocated there under the
new directory structure.

Since ROSE optimizes the use of libraries and A++ is the only current library that
ROSE can optimize, tests that test the ability of ROSE to optimize performance
are located in the RunTests directory.  Before any optimization can occur, we have to
be able to process the code through ROSE, this is sufficiently significant as a problem
that we have a separate directory of compile tests to test the ability of the preprocessor 
(and all of it's different phases). These compiler tests (code fragments that are or have been
a problem to compile properly) are located in the CompileTests directory.

   All translators build using ROSE should
be able to parse, process internally (generate ASTs), unparse, and
compile (with a C++ compiler)  the codes in each of these directories.

Different ROSE Translators (for testing different levels of infrastructure):
   (full test) testTranslator.C:
      This translator tests all parts of the CPP preprocessor support, parsing,
   AST generation, AST consistency tests, source code regeneration (unparsing),
   and compilation of the generated source code to build an object file or binary
   executable.  Except that no specific analysis or transformation is done this
   is a comprehensive of the base level ROSE infrastructure.  This translator is
   used for ALL of internal testing using ROSE on the regression test codes in
   the CompileTests directory. This is the most complete test of the base level
   of compiler infrastructure for ROSE (on C, C++, Fortran, PHP, OpenMP, UPC,
   and for binary analysis).

   (partial test) testParser.C:
      This translator only tests the ability to parse the input application.
   For C/C++ it runs the EDG frontend over the application (this includes the CPP
   preprocessing step, and EDG's semantic analysis).  For Fortran this translator
   runs only the CPP preprocessing step, the semantic analysis, and the parser
   (OFP) over the application.  Thus this is a test of the smallest subset of the
   base level ROSE infrastructure.

   (partial test) testAnalysis.C:
      This translator only test the CPP preprocessor support, parsing,
   AST generation, AST consistency tests.  It does build an object file or
   binary executable, but it does so using the original input file and not
   the code generated from the AST.  As a result this tests a subset of the
   base level ROSE infrastructure.

   (partial test) testCodeGeneration.C:
      This translator tests all the parts of the base level infrastructure
   except that the original source code is used to build an object file or binary
   executable. Thus the source code generation is done, but it is not used, and
   the object file or executable is generated from the original source file instead.
   This tests the ability of the code generation to complete, but does not test
   the quality of the generated source code (i.e. does not test if the generated
   source code will compile).  This test allows certain name qualification errors
   to pass undetected but permits the basic code generation infrastructure to be
   tested.

   (AST File I/O test) testAstFileIO.C:
      This translator tests the support in ROSE to generate the AST and dump it
   to a file and read it back in.  This AST File I/O is a critical piece of ROSE
   infrastructure for future work on AST merge, it writes and reads the AST as a
   binary formatted file.  This test code tests just the AST binary file I/O.
   There are a number of steps:
      1) The input file is read and the AST is generated.
      2) The AST is unparsed to generate source code to a file (generated source
         code file 1).
      3) The AST is dumped to a binary formatted file on disk (binary file 1).
      4) The AST is deleted (state is reset)
      5) The binary file of the AST is read from disk and the AST is generated
         (using binary file 1).
      6) Another source file is generated by unparsing the AST to a file
         (generated source code file 2).
      7) A diff of generated source code files 1 and 2 is run.
   There must be no differences between generated source code files 1 and 2
   for this tests to pass.

Directories:
   CompileTests:
      This directory contains code fragments that test the internal compiler mechanisms.
   Many code fragments or whole codes are present which have or continue to present
   problems in the compilation.  The CompileTests directory consists of several directories,
   the README file in that CompileTests directory gives more specific information.

   RunTests:
      This directory contains subdirectories representing code which uses libraries that
   ROSE can optimize.  It's purpose is to test the optimization mechanisms within ROSE.
   A testing harness (used in A++/P++ and developed by Brian Miller) will be use to report
   the performance of the optimizations at a later stage.

   roseTests:
      This directory tests the internal ROSE infrastructure. It contains separate 
   subdirectories for individual parts of ROSE. See ROSE/tests/roseTests/README 
   for details.

   translatorTests:
      This directory contains test translators and their input codes for regression tests of ROSE.


