/*
    * Redistribution and use of this software and associated documentation
    * ("Software"), with or without modification, are permitted provided
    * that the following conditions are met:
    *
    * 1. Redistributions of source code must retain copyright
    *    statements and notices.  Redistributions must also contain a
    *    copy of this document.
    *
   * 2. Redistributions in binary form must reproduce the
   *    above copyright notice, this list of conditions and the
   *    following disclaimer in the documentation and/or other
   *    materials provided with the distribution.
   *
   * 3. The name "Exolab" must not be used to endorse or promote
   *    products derived from this Software without prior written
   *    permission of Intalio, Inc.  For written permission,
   *    please contact info@exolab.org.
   *
   * 4. Products derived from this Software may not be called "Exolab"
   *    nor may "Exolab" appear in their names without prior written
   *    permission of Intalio, Inc. Exolab is a registered
   *    trademark of Intalio, Inc.
   *
   * 5. Due credit should be given to the Exolab Project
   *    (http://www.exolab.org/).
   *
   * THIS SOFTWARE IS PROVIDED BY INTALIO, INC. AND CONTRIBUTORS
   * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
   * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
   * INTALIO, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Copyright 2002-2003 (C) Intalio, Inc. All Rights Reserved.
   *
   * $Id: CastorTestCase.java 6787 2007-01-29 06:00:49Z ekuns $
   */
  package org.castor.xmlctf;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.net.URLClassLoader;
  import java.util.jar.JarFile;
  
  import junit.framework.Test;
  import junit.framework.TestCase;
  import junit.framework.TestSuite;
  
  import org.castor.xmlctf.util.FileServices;
  import org.exolab.castor.tests.framework.testDescriptor.MarshallingTest;
  import org.exolab.castor.tests.framework.testDescriptor.OnlySourceGenerationTest;
  import org.exolab.castor.tests.framework.testDescriptor.SchemaTest;
  import org.exolab.castor.tests.framework.testDescriptor.SourceGeneratorTest;
  import org.exolab.castor.tests.framework.testDescriptor.TestDescriptor;
  import org.exolab.castor.tests.framework.testDescriptor.TestDescriptorChoice;
  import org.exolab.castor.tests.framework.testDescriptor.UnitTestCase;
  import org.exolab.castor.xml.MarshalException;
  import org.exolab.castor.xml.ValidationException;
  
  /**
   * Abstracts a test case in the CTF (Castor Test Framework). A CTF test case can
   * be driven by a directory or by a JAR file.
   *
   * @author <a href="mailto:blandin@intalio.com">Arnaud Blandin</a>
   * @version $Revision: 6787 $ $Date: 2004-03-08 17:23:25 -0700 (Mon, 08 Mar 2004) $
   */
  public class CastorTestCase extends TestCase {
  
      /** An unknown type of Castor test case. */
      public static final short UNKNOWN   = -1;
      /** A directory-based Castor test case. */
      public static final short DIRECTORY = 0;
      /** A JAR-based Castor test case. */
      public static final short JAR       = 1;
  
      /** Name of the resource for the test descriptor XML document. */
      public static final String TEST_DESCRIPTOR = "TestDescriptor.xml";
      /** Name of the resource for the test descriptor XML document if a JAR file is used. */
      private static final String TEST_DESCRIPTOR_JAR = "META-INF/TestDescriptor.xml";
      /** File separator for this system. */
      private static final String FILE_SEPARATOR = System.getProperty("file.separator");
      /** Java version of the JVM we are running in. */
      private static final float JAVA_VERSION = Float.parseFloat(System.getProperty("java.specification.version"));
      /** True if we desire a lot of information on what is happening during the test. */
      private static final boolean VERBOSE;
  
      static {
          String v = System.getProperty(TestCaseAggregator.VERBOSE_PROPERTY);
         VERBOSE = (v != null && v.equals("true"));
         v = null;
     }
 
     /**
      * True if we dump the stack trace that is generated from any validation
      * exception or marshal exception caused by reading the XML Test
      * Description.
      */
     private static boolean _printStack;
 
     static {
         String v = System.getProperty(TestCaseAggregator.PRINT_STACK_TRACE);
         _printStack = (v != null && v.equals("true"));
         v = null;
     }
 
     /** Indicates whether or not the output root directory has been compiled. */
     private boolean _compiled = false;
     /** Class loader to use for the jar. */
     private ClassLoader _loader;
     /** The test descriptor from the jar. */
     private TestDescriptor _testDescriptor;
     /** The file that contains the tests. This can either be a directory or a jar file. */
     private final File _testFile;
     /** The Type of the test (directory or jar). */
     private final short _type;
     /** Place where the temporary files and other output are created. */
     private final File _outputRootFile;
     /** String containing the directory path from the test root to here. */
     private final String _directoryToHere;
 
     /**
      * Constructs a CTF test case given only a test case name.
      * @param name the name of the test case
      */
     public CastorTestCase(final String name) {
         super(name);
         _testFile        = null;
         _outputRootFile  = null;
         _directoryToHere = "";
         _type            = UNKNOWN;
     }
 
     /**
      * Constructs a CTF test case given a File (either a JAR file or a
      * directory) and a directory where temporary files will be placed. The test
      * case name will be derived from the file (JAR or directory) name.
      *
      * @param file Either a directory containing TestDescriptor.xml or a JAR
      *            file containing META-INF/TestDescriptor.xml
      * @param directoryToHere directory path leading to the current test.
      * @param outputRoot Directory where temporary files and output will go.
      */
     public CastorTestCase(final File file, final String directoryToHere, final String outputRoot) {
         super(directoryToHere);
         _directoryToHere = directoryToHere;
 
         if (file.isDirectory()) {
             _type = DIRECTORY;
             _outputRootFile = new File(outputRoot + FILE_SEPARATOR);
         } else {
             _type = JAR;
             try {
                 new JarFile(file);
                 String fileName = file.getName();
                 fileName = fileName.substring(0, fileName.lastIndexOf("."));
                 _outputRootFile = new File(outputRoot + FILE_SEPARATOR + fileName);
             } catch (java.util.zip.ZipException e) {
                 throw new IllegalStateException(file.getAbsolutePath() + " is not a valid JAR file.");
             } catch (java.io.IOException ie) {
                 throw new IllegalStateException(file.getAbsolutePath() + " is not a valid JAR file.");
             }
         }
 
         // Append to our current class loader the directory or JAR containing our test case
         try {
             URL[] urlList = {file.toURL()};
             _loader =  new URLClassLoader(urlList, this.getClass().getClassLoader());
         } catch (MalformedURLException urle) {
              //should never happen--> failure before
              urle.printStackTrace();
         }
         _testFile = file;
         _outputRootFile.mkdirs();
     }
 
     public ClassLoader getClassLoader() {
         return _loader;
     }
 
     public File getTestFile() {
         return _testFile;
     }
 
     public short getType() {
         return _type;
     }
 
     public String getDirectoryToHere() {
         return _directoryToHere;
     }
 
     public File getOutputRootFile() {
         return _outputRootFile;
     }
 
     /**
      * Returns a boolean that when true indicates the output directory has been
      * compiled. This is useful for preventing the compilation of a directory
      * multiple times when more than one test case exists in a given directory.
      *
      * @return true when the output root directory has already been compiled.
      */
     public boolean isDirectoryCompiled() {
         return _compiled;
     } //-- isDirectoryCompiled
 
    /**
      * Sets the ClassLoader to use for loading the resources for this test case.
      *
      * @param loader the class loader to use
      */
     public void setClassLoader(final ClassLoader loader) {
         _loader = loader;
     }
 
     /**
      * Sets a flag to indicate the output directory has been compiled. This
      * prevents compiling a directory multiple times unnecessarily when more
      * than one test case exists in a given directory.
      *
      * @param compiled true if the output directory for this test case has been
      *            compiled
      */
     public void setDirectoryCompiled(final boolean compiled) {
         _compiled = compiled;
     } //-- setDirectoryCompiled
 
     /**
      * Assembles and returns a test suite containing all known tests.
      *
      * @return A non-null test suite if we can load the test descriptor
      */
     public Test suite() {
         final InputStream descriptor;
         if (_type == JAR) {
             descriptor = _loader.getResourceAsStream(TEST_DESCRIPTOR_JAR);
         } else {
             descriptor = _loader.getResourceAsStream(TEST_DESCRIPTOR);
         }
 
         if (descriptor == null) {
             verbose("test '" + _testFile.getName() + "' has no TestDescriptor.xml");
             return null;
         }
 
         try {
             _testDescriptor = TestDescriptor.unmarshal(new InputStreamReader(descriptor));
         } catch (ValidationException ve) {
             verbose("Error reading: " + _testFile.getAbsolutePath());
             verbose("-> " + ve.toString());
             if (_printStack) {
                 ve.printStackTrace(System.out);
             }
             fail(ve.toString());
         } catch (MarshalException me) {
             verbose("Error reading: " + _testFile.getAbsolutePath());
             verbose("-> " + me.toString());
             if (_printStack) {
                 me.printStackTrace(System.out);
             }
             fail(me.toString());
         } finally {
             try {
                 descriptor.close();
             } catch (IOException e) {
                 // ignore
             }
         }
 
         if (_testDescriptor.hasMinimumJavaVersion()) {
             // Get minimum Java version & convert to our Canonical form
             float minVersion = _testDescriptor.getMinimumJavaVersion();
             if (minVersion >= 5F && minVersion < 10F) {
                 minVersion = 1.0F + (minVersion / 10F);
             }
             if (JAVA_VERSION < minVersion) {
                 verbose("-->Test requires at minimum Java " + minVersion + ", but we are running Java " + JAVA_VERSION);
                 verbose("-->Skipping the test");
                 return null;
             }
         }
 
         if (_testDescriptor.hasMaximumJavaVersion()) {
             // Get maximum Java version & convert to our Canonical form
             float maxVersion = _testDescriptor.getMaximumJavaVersion();
             if (maxVersion >= 5F && maxVersion < 10F) {
                 maxVersion = 1.0F + (maxVersion / 10F);
             }
             if (JAVA_VERSION > maxVersion) {
                 verbose("-->Test is designed to run up to Java " + maxVersion + ", but we are running Java " + JAVA_VERSION);
                 verbose("-->Skipping the test");
                 return null;
             }
         }
 
         final String suiteName = _directoryToHere + _testDescriptor.getName();
         final TestSuite suite = new TestSuite(suiteName);
         verbose("Creating '" + suiteName + "' test suite");
 
         TestDescriptorChoice choice = _testDescriptor.getTestDescriptorChoice();
         MarshallingTest marshallingTests      = choice.getMarshallingTest();
         SourceGeneratorTest sourceGenTests    = choice.getSourceGeneratorTest();
         SchemaTest schemaTests                = choice.getSchemaTest();
         OnlySourceGenerationTest genOnlyTests = choice.getOnlySourceGenerationTest();
 
         if (marshallingTests != null) {
             setUpMarshallingTests(suiteName, suite, marshallingTests);
         }
         if (sourceGenTests != null) {
             setUpSourceGeneratorTests(suiteName, suite, sourceGenTests);
         }
         if (schemaTests != null) {
             setUpSchemaTests(suiteName, suite, schemaTests);
         }
         if (genOnlyTests != null) {
             setUpGenerationOnlyTests(suiteName, suite, genOnlyTests);
         }
 
         return suite;
     }
 
     /**
      * Loops over all Marshalling tests from our TestDescriptor.xml, configures
      * each test and adds it to our suite.
      *
      * @param suiteName Test Suite name
      * @param suite the Test Suite to add all unit tests to
      * @param mar a collection of Marshalling Unit Tests
      */
     private void setUpMarshallingTests(final String suiteName, final TestSuite suite,
                                        final MarshallingTest mar) {
         for (int i = 0; i < mar.getUnitTestCaseCount(); ++i) {
             UnitTestCase tc = mar.getUnitTestCase(i);
             MarshallingFrameworkTestCase mftc = new MarshallingFrameworkTestCase(this, tc, mar);
             mftc._configuration = mar.getConfiguration();
             mftc.setTestSuiteName(suiteName);
             suite.addTest(mftc.suite());
         }
     }
 
     /**
      * Loops over all Source Generation tests from our TestDescriptor.xml,
      * configures each test and adds it to our suite.
      *
      * @param suiteName Test Suite name
      * @param suite the Test Suite to add all unit tests to
      * @param sg a collection of Source Generation Unit Tests
      */
     private void setUpSourceGeneratorTests(final String suiteName, final TestSuite suite,
                                            final SourceGeneratorTest sg) {
         for (int i = 0; i < sg.getUnitTestCaseCount(); ++i) {
             UnitTestCase tc = sg.getUnitTestCase(i);
             SourceGeneratorTestCase sgtc = new SourceGeneratorTestCase(this, tc, sg);
             sgtc.setTestSuiteName(suiteName);
             suite.addTest(sgtc.suite());
         }
     }
 
     /**
      * Loops over all Schema tests from our TestDescriptor.xml, configures each
      * test and adds it to our suite.
      *
      * @param suiteName Test Suite name
      * @param suite the Test Suite to add all unit tests to
      * @param schemaTest a collection of Schema Unit Tests
      */
     private void setUpSchemaTests(final String suiteName, final TestSuite suite,
                                   final SchemaTest schemaTest) {
         for (int i = 0; i < schemaTest.getUnitTestCaseCount(); i++) {
             UnitTestCase tc = schemaTest.getUnitTestCase(i);
             // Little trick: getUnitTestCaseChoice should not be null at this point
             String name = tc.getUnitTestCaseChoice().getSchema();
             if (name.equals("*")) {
                 File[] list = _testFile.listFiles();
                 for (int j = 0; j < list.length; ++j) {
                     String fileName = list[j].getName();
                     // FIXME:  It would be better to use a file filter and to make
                     // sure our SchemaReader can read this file
                     if (fileName.endsWith(FileServices.XSD)) {
                         makeIndividualSchemaTest(suiteName, suite, tc, fileName);
                     }
                 }
             } else {
                 makeIndividualSchemaTest(suiteName, suite, tc, name);
             }
         }
     }
 
     /**
      * Loops over all Only-Source-Generation tests from our TestDescriptor.xml,
      * configures each test and adds it to our suite.
      *
      * @param suiteName Test Suite name
      * @param suite the Test Suite to add all unit tests to
      * @param sg a collection of Source Generation Unit Tests
      */
     private void setUpGenerationOnlyTests(final String suiteName, final TestSuite suite,
                                           final OnlySourceGenerationTest sg) {
         for (int i = 0; i < sg.getUnitTestCaseCount(); ++i) {
             UnitTestCase tc = sg.getUnitTestCase(i);
             OnlySourceGenerationTestCase sgtc = new OnlySourceGenerationTestCase(this, tc, sg);
             sgtc.setTestSuiteName(suiteName);
             suite.addTest(sgtc.suite());
         }
     }
 
     /**
      * Makes an individual Schema test and adds it to our Test Suite.
      *
      * @param suiteName Test Suite name
      * @param suite the Test Suite to add all unit tests to
      * @param tc our Test Case
      * @param name Schema name
      */
     private void makeIndividualSchemaTest(final String suiteName, final TestSuite suite,
                                           final UnitTestCase tc, final String name) {
         tc.setName(suiteName + '#' + name);
         SchemaTestCase stc = new SchemaTestCase(this, tc);
         stc.setSchemaName(name);
         suite.addTest(stc);
     }
 
     /**
      * Prints the provided message if verbose is true.
      *
      * @param message The message to display if verbose is true.
      */
     private void verbose(final String message) {
         if (VERBOSE) {
             System.out.println(message);
         }
     }
 
 }