/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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$
 */

/*
 *
 * FactoryFeatureTest.java
 *
 */
package org.apache.qetest.xalanj2;

import java.io.File;
import java.util.Properties;
import java.util.Vector;

import javax.xml.XMLConstants;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;

import org.apache.qetest.FileBasedTest;
import org.apache.qetest.Logger;
import org.apache.qetest.OutputNameManager;
import org.apache.qetest.xsl.TraxDatalet;
import org.apache.xalan.processor.TransformerFactoryImpl;
import org.apache.xml.utils.DefaultErrorHandler;

//-------------------------------------------------------------------------

/**
 * Basic functionality test of various Factory configuration APIs.
 * Testing TransformerFactoryImpl.setAttribute, getFeature, etc.
 * @author shane_curcuru@lotus.com
 * @version $Id$
 */
public class FactoryFeatureTest extends FileBasedTest
{

    /** Provides nextName(), currentName() functionality.   */
    protected OutputNameManager outNames;

    /** Marker for datalet.options that notes setAttribute val.   */
    protected static final String SET_ATTRIBUTE = "setAttribute";

    /** Just initialize test name, comment, numTestCases. */
    public FactoryFeatureTest()
    {
        numTestCases = 4;  // REPLACE_num
        testName = "FactoryFeatureTest";
        testComment = "Basic functionality test of various Factory configuration APIs";
    }


    /**
     * Initialize this test - create output dir, outNames.  
     *
     * @param p Properties to initialize from (if needed)
     * @return false if we should abort the test; true otherwise
     */
    public boolean doTestFileInit(Properties p)
    {
        File outSubDir = new File(outputDir + File.separator + "xalanj2");
        if (!outSubDir.mkdirs())
            reporter.logWarningMsg("Could not create output dir: " + outSubDir);
        // Initialize an output name manager to that dir with .out extension
        outNames = new OutputNameManager(outputDir + File.separator + "xalanj2"
                                         + File.separator + testName, ".out");
        return true;
    }


    /**
     * Default values/settings of known features; simple error cases.
     *
     * @return false if we should abort the test; true otherwise
     */
    public boolean testCase1()
    {
        reporter.testCaseInit("Default values/settings of known features; simple error cases");

        TransformerFactory factory = null;
        try
        {
            factory = TransformerFactory.newInstance();

            try
            {
                reporter.logStatusMsg("Calling: factory.getAttribute(FEATURE_INCREMENTAL)");
                Object o = factory.getAttribute(TransformerFactoryImpl.FEATURE_INCREMENTAL);
                reporter.checkPass("factory.getAttribute(FEATURE_INCREMENTAL) returned a value");
                reporter.logWarningMsg("//@todo also validate default value:false");                
            }
            catch (IllegalArgumentException iae1)
            {
                // Note Xalan-J 2.2D06 does not fully implement this yet!
                reporter.checkPass("factory.getAttribute(FEATURE_INCREMENTAL) threw an expected IllegalArgumentException");
            }

            try
            {
                reporter.logStatusMsg("Calling: factory.getAttribute(FEATURE_OPTIMIZE)");
                Object o = factory.getAttribute(TransformerFactoryImpl.FEATURE_OPTIMIZE);
                reporter.checkPass("factory.getAttribute(FEATURE_OPTIMIZE) returned a value");
                reporter.logWarningMsg("//@todo also validate default value:true");                
            }
            catch (IllegalArgumentException iae1)
            {
                // Note Xalan-J 2.2D06 does not fully implement this yet!
                reporter.checkPass("factory.getAttribute(FEATURE_OPTIMIZE) threw an expected IllegalArgumentException");
            }

            // Set each value to it's non-default value and ensure no exceptions thrown
            reporter.logStatusMsg("Calling: factory.setAttribute(FEATURE_INCREMENTAL, Boolean.TRUE)");
            factory.setAttribute(TransformerFactoryImpl.FEATURE_INCREMENTAL, Boolean.TRUE);
            reporter.checkPass("factory.setAttribute(FEATURE_INCREMENTAL, Boolean.TRUE) returned OK");

            reporter.logStatusMsg("Calling: factory.setAttribute(FEATURE_OPTIMIZE, Boolean.FALSE)");
            factory.setAttribute(TransformerFactoryImpl.FEATURE_OPTIMIZE, Boolean.FALSE);
            reporter.checkPass("factory.setAttribute(FEATURE_OPTIMIZE, Boolean.FALSE) returned OK");

            // Try setting a non-recognized attribute
            try
            {
                reporter.logTraceMsg("Calling: factory.setAttribute(unrecognized-attribute, Boolean.FALSE)");
                factory.setAttribute("unrecognized-attribute", Boolean.FALSE);
                reporter.checkFail("factory.setAttribute(unrecognized-attribute,...) did not throw expected exception");
            }
            catch (IllegalArgumentException iae1)
            {
                reporter.checkPass("factory.setAttribute(unrecognized-attribute,...) properly threw: " + iae1.toString());
            }

            // Try setting a recognized attribute to a bad value
            try
            {
                reporter.logTraceMsg("Calling: factory.setAttribute(..., bad-object-value)");
                // Note: pass any sort of non-String, non-Boolean Object, since 
                //  this attribute only accepts ture|false as Strings or Booleans
                factory.setAttribute(TransformerFactoryImpl.FEATURE_OPTIMIZE, factory);
                reporter.checkFail("factory.setAttribute(..., bad-object-value) did not throw expected exception");
            }
            catch (IllegalArgumentException iae2)
            {
                reporter.checkPass("factory.setAttribute(..., bad-object-value) properly threw: " + iae2.toString());
            }
        }
        catch (Throwable t)
        {
            reporter.checkFail("setAttribute() tests threw: " + t.toString());
            reporter.logThrowable(reporter.ERRORMSG, t, "setAttribute() tests threw");
        }

        reporter.testCaseClose();
        return true;
    }


    /**
     * Validate transforms with FEATURE_INCREMENTAL on/off.
     *
     * @return false if we should abort the test; true otherwise
     */
    public boolean testCase2()
    {
        reporter.testCaseInit("Validate transforms with FEATURE_INCREMENTAL on/off");

        // Get our list of xsl datalets to test
        Vector datalets = buildDatalets(null, new File(inputDir), 
                                        new File(outputDir), new File(goldDir));

        // Skip Validating datalets - they're hard-coded
        int numDatalets = datalets.size();
        reporter.logInfoMsg("processFileList-equivalent() with " + numDatalets
                            + " potential tests");

        TransformerFactory factory = null;
        // Iterate over every datalet and test it with both feature settings
        for (int ctr = 0; ctr < numDatalets; ctr++)
        {
            TraxDatalet datalet = (TraxDatalet)datalets.elementAt(ctr);
            try
            {
                // Get a new factory for each datalet - not strictly necessary
                factory = TransformerFactory.newInstance();

                // Test both a Boolean object..
                reporter.logStatusMsg("Calling: factory.setAttribute(FEATURE_INCREMENTAL, Boolean.TRUE)");
                factory.setAttribute(TransformerFactoryImpl.FEATURE_INCREMENTAL, Boolean.TRUE);
                datalet.options.put(SET_ATTRIBUTE, "FEATURE_INCREMENTAL, Boolean.TRUE");
                datalet.outputName = outNames.nextName();
                transformAndCheck(factory, datalet);

                reporter.logStatusMsg("Calling: factory.setAttribute(FEATURE_INCREMENTAL, Boolean.FALSE)");
                factory.setAttribute(TransformerFactoryImpl.FEATURE_INCREMENTAL, Boolean.FALSE);
                datalet.options.put(SET_ATTRIBUTE, "FEATURE_INCREMENTAL, Boolean.FALSE");
                datalet.outputName = outNames.nextName();
                transformAndCheck(factory, datalet);

                // .. and a String representation of true|false
                reporter.logStatusMsg("Calling: factory.setAttribute(FEATURE_INCREMENTAL, 'true')");
                factory.setAttribute(TransformerFactoryImpl.FEATURE_INCREMENTAL, "true");
                datalet.options.put(SET_ATTRIBUTE, "FEATURE_INCREMENTAL, 'true'");
                datalet.outputName = outNames.nextName();
                transformAndCheck(factory, datalet);

                reporter.logStatusMsg("Calling: factory.setAttribute(FEATURE_INCREMENTAL, 'false')");
                factory.setAttribute(TransformerFactoryImpl.FEATURE_INCREMENTAL, "false");
                datalet.options.put(SET_ATTRIBUTE, "FEATURE_INCREMENTAL, 'false'");
                datalet.outputName = outNames.nextName();
                transformAndCheck(factory, datalet);
            } 
            catch (Throwable t)
            {
                reporter.logThrowable(Logger.ERRORMSG, t, datalet.getDescription() + "(" + ctr + ") threw");
                reporter.checkFail(datalet.getDescription() + "(" + ctr + ") threw: " + t.toString());
            }
        }  // of while...

        reporter.testCaseClose();
        return true;
    }


    /**
     * Validate transforms with FEATURE_OPTIMIZE on/off.
     *
     * @return false if we should abort the test; true otherwise
     */
    public boolean testCase3()
    {
        reporter.testCaseInit("Validate transforms with FEATURE_OPTIMIZE on/off");

        // Get our list of xsl datalets to test
        Vector datalets = buildDatalets(null, new File(inputDir), 
                                        new File(outputDir), new File(goldDir));

        // Skip Validating datalets - they're hard-coded
        int numDatalets = datalets.size();
        reporter.logInfoMsg("processFileList-equivalent() with " + numDatalets
                            + " potential tests");

        TransformerFactory factory = null;
        // Iterate over every datalet and test it with both feature settings
        for (int ctr = 0; ctr < numDatalets; ctr++)
        {
            TraxDatalet datalet = (TraxDatalet)datalets.elementAt(ctr);
            try
            {
                // Get a new factory for each datalet - not strictly necessary
                factory = TransformerFactory.newInstance();

                // Test both a Boolean object..
                reporter.logInfoMsg("Calling: factory.setAttribute(FEATURE_OPTIMIZE, Boolean.TRUE)");
                factory.setAttribute(TransformerFactoryImpl.FEATURE_OPTIMIZE, Boolean.TRUE);
                datalet.options.put(SET_ATTRIBUTE, "FEATURE_OPTIMIZE, Boolean.TRUE");
                datalet.outputName = outNames.nextName();
                transformAndCheck(factory, datalet);

                reporter.logInfoMsg("Calling: factory.setAttribute(FEATURE_OPTIMIZE, Boolean.FALSE)");
                factory.setAttribute(TransformerFactoryImpl.FEATURE_OPTIMIZE, Boolean.FALSE);
                datalet.options.put(SET_ATTRIBUTE, "FEATURE_OPTIMIZE, Boolean.FALSE");
                datalet.outputName = outNames.nextName();
                transformAndCheck(factory, datalet);

                // .. and a String representation of true|false
                reporter.logInfoMsg("Calling: factory.setAttribute(FEATURE_OPTIMIZE, 'true')");
                factory.setAttribute(TransformerFactoryImpl.FEATURE_OPTIMIZE, "true");
                datalet.options.put(SET_ATTRIBUTE, "FEATURE_OPTIMIZE, 'true'");
                datalet.outputName = outNames.nextName();
                transformAndCheck(factory, datalet);

                reporter.logInfoMsg("Calling: factory.setAttribute(FEATURE_OPTIMIZE, 'false')");
                factory.setAttribute(TransformerFactoryImpl.FEATURE_OPTIMIZE, "false");
                datalet.options.put(SET_ATTRIBUTE, "FEATURE_OPTIMIZE, 'false'");
                datalet.outputName = outNames.nextName();
                transformAndCheck(factory, datalet);
            } 
            catch (Throwable t)
            {
                reporter.logThrowable(Logger.ERRORMSG, t, datalet.getDescription() + "(" + ctr + ") threw");
                reporter.checkFail(datalet.getDescription() + "(" + ctr + ") threw: " + t.toString());
            }
        }  // of while...

        reporter.testCaseClose();
        return true;
    }
    
    /**
     * Validate transforms with FEATURE_SECURE_PROCESSING on/off.
     *
     * @return false if we should abort the test; true otherwise
     */
    public boolean testCase4()
    {
        reporter.testCaseInit("Validate transforms with FEATURE_SECURE_PROCESSING on/off");
        
        try
        {
            TransformerFactory factory = TransformerFactory.newInstance();
            
            // The test xsl contains an extension function. The transformation is successful
            // when FEATURE_SECURE_PROCESSING is set to false.
            factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, false);
            
            TraxDatalet datalet = new TraxDatalet();
            datalet.setDescription("Test secure processing feature:");
            datalet.setNames(inputDir + File.separator + "xalanj2", "SecureProcessingTest");
            datalet.goldName = goldDir + File.separator + "xalanj2" + File.separator + "SecureProcessingTest.out";
            datalet.outputName = outNames.nextName();
            transformAndCheck(factory, datalet);
                        
            try
            {
                // TransformerException is thrown when FEATURE_SECURE_PROCESSING is set to true.
                factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
                Transformer transformer = factory.newTransformer(datalet.getXSLSource());
                transformer.setErrorListener(new DefaultErrorHandler());
                transformer.transform(datalet.getXMLSource(), new StreamResult(datalet.outputName));
                reporter.checkFail("Expected TransformerException not thrown when secure processing feature is set to true.");
            }
            catch (javax.xml.transform.TransformerException e)
            {
                reporter.checkPass("TransformerFactory with FEATURE_SECURE_PROCESSING set to true threw TransformerException:  " + e.toString());
            }
        }
        catch (Throwable t)
        {
            reporter.logThrowable(Logger.ERRORMSG, t, "Failed in secure processing feature test");
            reporter.checkFail("Failed in secure processing feature test");
        }
        
        reporter.testCaseClose();
        return true;        
    }


    /**
     * Create a vector of filled-in datalets to be tested.
     *
     * This currently is hard-coded to return a static Vector
     * of Datalets that are simply constructed here.
     * In the future we should add a way to read them in from disk.
     * The 'what' files we should test.
     * 
     * @param files Vector of local path\filenames to be tested
     * This is currently ignored
     * @param testLocation File denoting directory where all 
     * .xml/.xsl tests are found
     * @param outLocation File denoting directory where all 
     * output files should be put
     * @param goldLocation File denoting directory where all 
     * gold files are found
     * @return Vector of StylesheetDatalets that are fully filled in,
     * i.e. outputName, goldName, etc are filled in respectively 
     * to inputName
     */
    public Vector buildDatalets(Vector files, File testLocation, 
                                File outLocation, File goldLocation)
    {
        Vector v = new Vector();
        // identity transform
        // Info about the minitest: note gold file naming is different
        TraxDatalet d = new TraxDatalet();
        d.setDescription("Identity transform and:");
        d.setNames(inputDir + File.separator + "trax", "identity");
        d.goldName = goldDir + File.separator + "trax" + File.separator + "identity.out";
        v.addElement(d);

        // Info about the minitest: note gold file naming is different
        d = new TraxDatalet();
        d.setDescription("Basic Minitest file and:");
        d.setNames(inputDir, "Minitest");
        d.goldName = goldDir + File.separator + "Minitest-xalanj2.out";
        v.addElement(d);

        // All done: return full vector
        return v;
    }


    /**
     * Convenience method to do a transform and validate output.  
     * The 'how' of a specific test.
     * @param factory to use to create transformers
     * @param datalet to use (TraxDatalet)
     */
    protected void transformAndCheck(TransformerFactory factory, 
                                     TraxDatalet datalet)
    {
        // Validate arguments
        if ((null == factory) || (null == datalet))
        {
            reporter.checkErr(datalet.getDescription() + " with null args!");
            return;
        }
        final String desc = datalet.getDescription() + datalet.options.get(SET_ATTRIBUTE);

        try
        {
            reporter.logStatusMsg("transformAndCheck of: " + desc);
            Transformer transformer = factory.newTransformer(datalet.getXSLSource());
            reporter.logTraceMsg("About to transform...");
            transformer.transform(datalet.getXMLSource(), new StreamResult(datalet.outputName));

            if (Logger.PASS_RESULT 
                != fileChecker.check(reporter, 
                                     new File(datalet.outputName), 
                                     new File(datalet.goldName), 
                                     desc + " into " + datalet.outputName)
               )
                reporter.logInfoMsg(desc + " failure reason:" + fileChecker.getExtendedInfo());
        }
        catch (Throwable t)
        {
            reporter.logThrowable(reporter.ERRORMSG, t, desc + " threw");
            reporter.checkFail(desc + " threw: " + t.toString());
        }        
    }


    /**
     * Convenience method to print out usage information - update if needed.  
     * @return String denoting usage of this test class
     */
    public String usage()
    {
        return ("Common [optional] options supported by FactoryFeatureTest:\n"
                + "(Note: assumes inputDir=.\\tests\\api)\n"
                + super.usage());   // Grab our parent classes usage as well
    }


    /**
     * Main method to run test from the command line - can be left alone.  
     * @param args command line argument array
     */
    public static void main(String[] args)
    {
        FactoryFeatureTest app = new FactoryFeatureTest();
        app.doMain(args);
    }
}