/*
    * Copyright 2006 Edward Kuns
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   * $Id: TestWithReferenceDocument.java 0000 2006-10-19 22:00:00Z ekuns $
   */
  package org.castor.xmlctf;
  
  import java.io.File;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.InputStream;
  
  import junit.framework.TestCase;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.castor.xmlctf.util.CTFUtils;
  import org.exolab.castor.tests.framework.testDescriptor.FailureType;
  import org.exolab.castor.tests.framework.testDescriptor.types.FailureStepType;
  import org.exolab.castor.xml.XMLContext;
  
  /**
   * Implements a test case that tests code written by the XML source generator.
   * This class uses the generated source to read and write an XML document,
   * comparing the XML document written against the reference document that was
   * originally read in.
   * <p>
   * The test follows this sequence:
   *
   * <ol>
   *   <li>Unmarshals the given input file (if any).</li>
   *   <li>Compare the result object with the provided object model (if any).</li>
   *   <li>Marshals the object to a file.</li>
   *   <li>Unmarshals the created file.</li>
   *   <li>Check that the result object is equal to the start object.</li>
   * </ol>
   *
   * @author <a href="mailto:gignoux@kernelcenter.org">Sebastien Gignoux</a>
   * @author <a href="mailto:blandin@intalio.com">Arnaud Blandin</a>
   * @author <a href="mailto:edward.kuns@aspect.com">Edward Kuns</a>
   * @version $Revision: 0000 $ $Date: $
   */
  class TestWithReferenceDocument extends TestCase {
      
      private static final Log LOG = LogFactory.getLog(TestWithReferenceDocument.class);
      
      /** We add this fixed string to the end of our testcase name. */
      private static final String REFERENCE = "_ReferenceDocument";
  
      /** We delegate all actions to this test case. */
      private final XMLTestCase      _delegate;
      /** Used only to retrieved the classloader. */
      protected final CastorTestCase _test;
      /** The failure object that is not null is the test intends to fail. */
      protected final FailureType    _failure;
      /** Class name of the ObjectModelBuilder. */
      protected final String         _builderClassName;
      /** Header of the name of all our output files ... marshaled and dumped. */
      protected final String         _outputName;
      /** Input file for test XML. (May be null if the builder class is provided.) */
      protected final String         _inputName;
      /** Gold file filename, really only useful if a class builder and no input file is given. */
      protected final String         _goldFileName;
  
      /**
       * Blank constructor for this test case.  This contructor is not useful, since
       * no delegate test case is provided.
       * @param name Name of our delegate test case
       */
      TestWithReferenceDocument(String name) {
          super(name+REFERENCE);
          throw new IllegalArgumentException("You cannot use the name-only constructor");
      }
  
      /**
       * Constructs a test case that when invoked will delegate to the provided
       * test case.
       * @param name Name of our delegate test case
       * @param tc
       */
      TestWithReferenceDocument(String name, XMLTestCase tc) {
          super(name+REFERENCE);
          _delegate         = tc;
          _test             = tc._test;
          _failure          = tc._failure;
          _outputName       = tc._name.replace(' ', '_') + "-testWithReferenceDocument.xml";
          _builderClassName = tc._unitTest.getObjectBuilder();
         _inputName        = tc._unitTest.getInput();
 
         // Gold File should be set to input file if no gold file is specified
         // but some tests fail (genuine failures) so for now this is disabled.
 
         if (tc._unitTest.getGoldFile() != null) {
             _goldFileName = tc._unitTest.getGoldFile();
         } else {
             _goldFileName = _inputName;
         }
     }
 
     /**
      * Provides setup for our delegated test case, depending on the type of
      * test case we are delegating for.
      * @throws Exception if anything goes wrong during setup
      */
     protected void setUp() throws Exception {
         if (_delegate == null) {
             throw new IllegalStateException("No test specified to set up.");
         }
 
         _delegate.setXMLContext(new XMLContext());
         _delegate.setUp();
 //        if (_delegate instanceof MarshallingFrameworkTestCase) {
 //            ((MarshallingFrameworkTestCase)_delegate).setUp();
 //        } else if (_delegate instanceof SourceGeneratorTestCase) {
 //            ((SourceGeneratorTestCase)_delegate).setUp();
 //        }
     }
 
     /**
      * Provides tear down for our delegated test case, depending on the type of
      * test case we are delegating for.
      * @throws Exception if anything goes wrong during teardown
      */
     protected void tearDown() throws Exception {
         if (_delegate == null) {
             throw new IllegalStateException("No test specified to tear down.");
         }
         _delegate.tearDown();
 //        if (_delegate instanceof MarshallingFrameworkTestCase) {
 //            ((MarshallingFrameworkTestCase)_delegate).tearDown();
 //        } else if (_delegate instanceof SourceGeneratorTestCase) {
 //            ((SourceGeneratorTestCase)_delegate).tearDown();
 //        }
     }
 
     /**
      * Runs our test case using our delegate object where necessary.
      * <p>
      * FIXME: Fix this so it throws only specific and necessary exceptions
      * @throws Exception if anything goes wrong
      */
     public void runTest() throws Exception { // FIXME - temporarily throws Exception
         if (_delegate == null) {
             throw new IllegalStateException("No test specified to be run.");
         }
 
         verbose("\n------------------------------");
         verbose("Test with reference documents");
         verbose("------------------------------\n");
         if (_delegate._skip) {
             verbose("-->Skipping the test");
             return;
         }
 
         // 1. Get reference document from unmarshaler + input file (if input file is provided)
         Object refUnmarshal;
         try {
             refUnmarshal = getUnmarshaledReference();
         } catch (Exception e) {
             if (_delegate._verbose) {
                 LOG.error("Problem unmarshalling input file from disk", e);
             }
             if (!_delegate.checkExceptionWasExpected(e, FailureStepType.UNMARSHAL_REFERENCE)) {
                 fail("Exception Unmarshaling from disk " + e);
             }
             return;
         }
 
         // 2. Get reference document from builder (if builder is provided) -- should never fail
         Object refGenerated = getBuilderReference();
 
         // 3. If we have two reference objects, make sure they are the same -- should never fail
         if (refUnmarshal != null && refGenerated != null) {
             compareReferenceObjects(refUnmarshal, refGenerated);
         }
 
         // 4. Pick our reference object (at least one should be non-null)
         final Object ref = (refUnmarshal != null) ? refUnmarshal : refGenerated;
         if (ref == null) {
             throw new Exception("There is no valid input file or hardcoded object in '" + _delegate._name + "'");
         }
 
         // 5. Marshal our reference object to disk
         File marshal_output;
         try {
             marshal_output = _delegate.testMarshal(ref, _outputName);
         } catch (Exception e) {
             if (!_delegate.checkExceptionWasExpected(e, FailureStepType.MARSHAL_TO_DISK)) {
                 fail("Exception Unmarshaling from disk " + e);
             }
             return;
         }
 
         if (_failure != null && _failure.getContent() && _failure.getFailureStep() != null &&
             _failure.getFailureStep().equals(FailureStepType.MARSHAL_TO_DISK)) {
             fail("Marshaling the reference document to disk was expected to fail, but succeeded");
             return;
         }
 
         // 6. Compare marshaled document with gold file (if one was provided)
         if (_goldFileName != null && _goldFileName.length() > 0) {
             int result = CTFUtils.compare(_delegate._outputRootFile + "/" +  _goldFileName, marshal_output.getAbsolutePath());
             verbose("----> Compare marshaled document to gold file '" + _goldFileName + "': " + ((result == 0)?"OK":"### Failed ### "));
 
             final boolean expectedToFail = _failure != null && _failure.getContent()
                     && _failure.getFailureStep() != null
                     && _failure.getFailureStep().equals(FailureStepType.COMPARE_TO_REFERENCE);
 
             verbose("----> expectedToFail when comparing to reference: " + expectedToFail);
             
             if (_failure == null || !_failure.getContent()) {
                 assertEquals("The Marshaled object differs from the gold file", 0, result);
             } else if (expectedToFail) {
                 assertTrue("The Marshaled object was expected to differ from the" +
                            " gold file, but did not", result > 0);
             }
         }
 
         // 7. Marshal the Listener and compare it to the listener gold file, if any
         compareListenerToItsGoldFile();
 
         // 8. Unmarshal the output file
         Object unmarshaledOutput = null;
         if (_builderClassName != null) {
             try {
                 unmarshaledOutput = _delegate.testUnmarshal(marshal_output);
             } catch (Exception e) {
                 LOG.error("Problem unmarshalling output from marshalling step", e);
                 if (!_delegate.checkExceptionWasExpected(e, FailureStepType.SECOND_UNMARSHAL)) {
                     fail("Exception Unmarshaling from disk " + e);
                 }
                 return;
             }
 
             if (_failure != null && _failure.getContent() && _failure.getFailureStep() != null &&
                     _failure.getFailureStep().equals(FailureStepType.SECOND_UNMARSHAL)) {
                 fail("Second unmarshaling was expected to fail, but succeeded");
                 return;
             }
 
         }
         // 9. Compare unmarshaled output file to ObjectModelBuilder if any.
         // TODO: Fix the tests that fail this comparison!
         // Right now many test classes (under xml/MasterTestSuite) do not override equals.
         // We could check "(ref instanceof CastorTestable)" except that several srcgen
         // tests fails this check.  (Probably bugs!)  For now we have this bogus
         // _builderClassName check.  We ideally want to ALWAYS do this comparison.
         if (_builderClassName != null && unmarshaledOutput != null) {
             // the equals method must be overriden
             boolean result  = unmarshaledOutput.equals(ref);
             if (result == false) {
                 verbose("Make sure the reference object model overrides Object#equals");
             }
             verbose("Compare to reference object: " + ((result)?"OK":" ### Failed ### "));
 
             final FailureStepType step = _failure != null ? _failure.getFailureStep() : null;
             final boolean expectedToFail = _failure != null && _failure.getContent()
                            && (step == null || step.equals(FailureStepType.SECOND_COMPARE));
 
             if (_failure == null || !_failure.getContent()) {
                 assertTrue("The initial reference object and the one resulting of the " +
                            "marshal/unmarshal process are different", result);
             } else if (expectedToFail) {
                 assertFalse("Comparing the reference object to the marshal+unmarshaled " +
                             "one was expected to fail, but succeeded", result);
             }
 
             if (expectedToFail ^ result) {
                 return;
             }
         }
 
         if (_builderClassName != null) {
             if (_failure != null && _failure.getContent()) {
                 fail("The test with reference document was expected to fail, but passed");
             }
         }
     }
 
     /**
      * Returns a reference document as generated by unmarshaling the input
      * document provided, if one was provided.
      * @return a reference document from an unmarshaled input document
      * @throws Exception if anything goes wrong loading the input document
      */
     private Object getUnmarshaledReference() throws Exception {
         InputStream _input = null;
         if (_inputName != null) {
             _input = _test.getClassLoader().getResourceAsStream(_inputName);
             assertNotNull("The input file '" + _inputName + "' cannot be found.", _input);
         }
 
         verbose("--> Unmarshaling '" + _inputName  + "'\n");
 
         Object refUnmarshal = null;
         if (_input != null) {
             refUnmarshal = _delegate.testUnmarshal(_input);
             _input.close();
         }
 
         // If we didn't throw an exception, make sure we were supposed to succeed
 
         if (_failure != null && _failure.getContent() && _failure.getFailureStep() != null &&
             _failure.getFailureStep().equals(FailureStepType.UNMARSHAL_REFERENCE)) {
             fail("Unmarshaling the reference document was expected to fail, but succeeded");
         }
 
         assertNotNull("Unmarshaling '" + _inputName + "' results in a NULL object.", refUnmarshal);
 
         return refUnmarshal;
     }
 
     /**
      * Returns a reference document as generated by the hard-coded
      * ObjectModelBuilder.
      *
      * @return a reference document as generated by the hard-coded
      *         ObjectModelBuilder
      * @throws Exception if anything goes wrong executing creating the
      *             ObjectModelBuilder or using it to create the reference
      *             document.
      */
     private Object getBuilderReference() throws Exception {
         Object generated = null;
         if (_builderClassName != null) {
             generated = _delegate.buildObjectModel(_builderClassName);
             assertNotNull("The generated object with '" + _builderClassName + "' is null", generated);
         }
         return generated;
     }
 
     /**
      * Make sure the ObjectModelBuilder object and the unmarshaled input document
      * created the same object.
      * @param refUnmarshal reference object created from unmarshaling an input document
      * @param refGenerated reference object created by an ObjectModelBuilder
      * @throws IOException if we get an error dumping the objects to disk.
      */
     private void compareReferenceObjects(Object refUnmarshal, Object refGenerated) throws IOException {
         //the object model must override the equals method.
         boolean result = refGenerated.equals(refUnmarshal);
         verbose("----> Compare unmarshaled document to reference object: " + ((result)?"OK":"### Failed ### "));
         if (result == false) {
             verbose("Make sure the reference object model overrides Object#equals");
         }
 
         if (result == false && refGenerated instanceof CastorTestable) {
             // try to dump the unmarshaled object and the reference object
             FileWriter writer = new FileWriter(new File(_delegate._outputRootFile, _outputName + "-refModel.dump"));
             writer.write(((CastorTestable)refGenerated).dumpFields());
             writer.close();
 
             writer = new FileWriter(new File(_delegate._outputRootFile, _outputName + "-refUnmarshal.dump"));
             writer.write(((CastorTestable)refUnmarshal).dumpFields());
             writer.close();
         }
 
         assertTrue("The unmarshaled reference object differs from the hardcoded reference object.", result);
     }
 
     /**
      * Tests that the listener saw what it was supposed to see. If we have a
      * listener configured, marshal it to disk (now that it listened to the
      * previous marshal) and compare it to the listener gold file, if any.
      * <p>
      * We have to unregister the listener before we do anything. When we marshal
      * the MarshalListener, for every item marshaled the listener may grow and
      * may have more to marshal, and thus we may end up in an endless loop. For
      * example, a simple implementation of MarshalListener could log each
      * pre/post marshal invocation on a Vector to allow for later comparisons.
      * But this means that the object *being marshaled* keeps getting data added
      * to it during the marshaling!
      *
      * @throws Exception if anything goes wrong during the test
      */
     private void compareListenerToItsGoldFile() throws Exception {
         if (_delegate._listenerGoldFile == null || _delegate._listener == null) {
             return;
         }
 
         verbose("Compare listener to gold file: " + _delegate._listenerGoldFile);
 
         // Get the listener (before we unregister it!)
         Object listener = _delegate._listener;
 
         // Unregister the listener
         _delegate._listener = null;
 
         File outputFile;
         try {
             outputFile = _delegate.testMarshal(listener, "Listener-" + _outputName);
         } catch (Exception e) {
             if (!_delegate.checkExceptionWasExpected(e, FailureStepType.LISTENER_COMPARISON)) {
                 fail("Exception Unmarshaling from disk " + e);
             }
             return;
         }
 
         int result = CTFUtils.compare(_delegate._outputRootFile + "/" +  _delegate._listenerGoldFile, outputFile.getAbsolutePath());
         verbose("----> Compare marshaled document to gold file '" + _delegate._listenerGoldFile + "': " + ((result == 0)?"OK":"### Failed ### "));
 
         if (_failure != null && _failure.getContent()) {
             // Are we are supposed to fail AT THIS STEP?  If not, don't check
             if (_failure.getFailureStep() != null &&
                 _failure.getFailureStep().equals(FailureStepType.LISTENER_COMPARISON)) {
                 assertTrue("The Marshaled Listener is supposed to differ from its gold file", result != 0);
             }
         } else {
             assertEquals("The Marshaled Listener differs from its gold file", 0, result);
         }
     }
 
     private void verbose(String message) {
         _delegate.verbose(message);
     }
 
 }