path: root/test/java/src/org/apache/qetest/xalanj2/TraceListenerTest.java

/*
 * 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$
 */

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

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

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.trace.TraceListener;
import org.apache.xalan.trace.TraceManager;
import org.apache.xalan.transformer.TransformerImpl;
import org.apache.xalan.transformer.XalanProperties;

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

/**
 * Basic functionality testing of TraceListener interface and etc.
 * @author shane_curcuru@lotus.com
 * @version $Id$
 */
public class TraceListenerTest extends FileBasedTest
{

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

    /** Simple test to do tracing on.  */
    protected TraxDatalet testFileInfo = new TraxDatalet();

    /** Another '2' Simple test to do tracing on.  */
    protected TraxDatalet testFileInfo2 = new TraxDatalet();

    /** Subdirectory under test\tests\api for our xsl/xml files.  */
    public static final String X2J_SUBDIR = "xalanj2";


    /** Just initialize test name, comment, numTestCases. */
    public TraceListenerTest()
    {
        numTestCases = 4;  // REPLACE_num
        testName = "TraceListenerTest";
        testComment = "Basic functionality testing of TraceListener interface and etc";
    }


    /**
     * Initialize this test - Set names of xml/xsl test files,
     * REPLACE_other_test_file_init.  
     *
     * @param p Properties to initialize from (if needed)
     * @return false if we should abort the test; true otherwise
     */
    public boolean doTestFileInit(Properties p)
    {
        // NOTE: 'reporter' variable is already initialized at this point

        // Used for all tests; just dump files in trax subdir
        File outSubDir = new File(outputDir + File.separator + X2J_SUBDIR);
        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 + X2J_SUBDIR
                                         + File.separator + testName, ".out");

        // NOTE: validation is tied to details within this file!
        testFileInfo.setDescription("Simple transform: TraceListenerTest");
        testFileInfo.setNames(inputDir + File.separator + X2J_SUBDIR, "TraceListenerTest");
        testFileInfo.goldName = goldDir + File.separator + X2J_SUBDIR + File.separator + "TraceListenerTest.out";
        
        testFileInfo2.setDescription("for-each transform: TraceListenerTest2");
        testFileInfo2.setNames(inputDir + File.separator + X2J_SUBDIR, "TraceListenerTest2");
        testFileInfo2.goldName = goldDir + File.separator + X2J_SUBDIR + File.separator + "TraceListenerTest2.out";
        return true;
    }


    /**
     * Quick smoketest of TraceListener; verify it traces something.
     *
     * @return false if we should abort the test; true otherwise
     */
    public boolean testCase1()
    {
        reporter.testCaseInit("Quick smoketest of TraceListener");
        reporter.logWarningMsg("Note: limited validation: partly just a crash test so far.");

        try
        {
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer(testFileInfo.getXSLSource());

            reporter.logInfoMsg("Transformer created, addTraceListener..."); 
            LoggingTraceListener ltl = new LoggingTraceListener(reporter);
            TraceManager traceManager = ((TransformerImpl)transformer).getTraceManager();
            reporter.check((null != traceManager), true, "getTraceManager is non-null");
            reporter.logStatusMsg("traceManager.hasTraceListeners() is: " + traceManager.hasTraceListeners());
            traceManager.addTraceListener((TraceListener)ltl);
            reporter.check(traceManager.hasTraceListeners(), true, "traceManager.hasTraceListeners() true after adding one");
         
            reporter.logInfoMsg("About to create output: " + outNames.nextName()); 
            transformer.transform(testFileInfo.getXMLSource(),
                                  new StreamResult(outNames.currentName()));
            reporter.checkPass("Crash test only: returned from transform() call");
            int[] tracedEvents = ltl.getCounters();
            reporter.logStatusMsg("Last event traced:" + ltl.getLast());
            reporter.logStatusMsg("Events traced:" + tracedEvents[LoggingTraceListener.TYPE_TRACE]
                                  + " events generated:" + tracedEvents[LoggingTraceListener.TYPE_GENERATED]
                                  + " events selected:" + tracedEvents[LoggingTraceListener.TYPE_SELECTED]);
            reporter.check(tracedEvents[LoggingTraceListener.TYPE_SELECTED], 3, 
                           "Correct number of selected events for testfile " + testFileInfo.getDescription());
            reporter.logStatusMsg("//@todo add more validation of trace events");
        }
        catch (Throwable t)
        {
            reporter.logThrowable(Logger.ERRORMSG, t, "testCase1a threw: ");
            reporter.checkFail("testCase1a threw: " + t.toString());
        }

        try
        {
/**** Temporarily comment out - my bad, missed checkin on testFileInfo2 tests! 27-jul-01 -sc ****
            // Try again with a different file with new Ex listener (should be parameterized)
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer(testFileInfo2.getXSLSource());

            reporter.logInfoMsg("Transformer2 created, addTraceListener(Ex)..."); 
            LoggingTraceListenerEx ltl = new LoggingTraceListenerEx(reporter);
            TraceManager traceManager = ((TransformerImpl)transformer).getTraceManager();
            traceManager.addTraceListener((TraceListener)ltl);
         
            reporter.logInfoMsg("About to create output: " + outNames.nextName()); 
            transformer.transform(testFileInfo2.getXMLSource(),
                                  new StreamResult(outNames.currentName()));
            reporter.checkPass("Crash test only: returned from transform() call");
            int[] tracedEvents = ltl.getCounters();
            int selectedEndCtr = ltl.getCounterEx();
            reporter.logStatusMsg("Last event traced:" + ltl.getLast());
            reporter.logStatusMsg("Events traced:" + tracedEvents[LoggingTraceListener.TYPE_TRACE]
                                  + " events generated:" + tracedEvents[LoggingTraceListener.TYPE_GENERATED]
                                  + " events selected:" + tracedEvents[LoggingTraceListener.TYPE_SELECTED]
                                  + " events selectEnd:" + selectedEndCtr);
            reporter.check(tracedEvents[LoggingTraceListener.TYPE_SELECTED], 10, 
                           "Correct number of selected events for testfile " + testFileInfo2.getDescription());
            reporter.check(selectedEndCtr, 5, 
                           "Correct number of selectedEnd events for testfile " + testFileInfo2.getDescription());
**** Temporarily comment out - my bad, missed checkin on testFileInfo2 tests! 27-jul-01 -sc  ****/
        }
        catch (Throwable t)
        {
            reporter.logThrowable(Logger.ERRORMSG, t, "testCase1b threw: ");
            reporter.checkFail("testCase1b threw: " + t.toString());
        }

        reporter.testCaseClose();
        return true;
    }


    /**
     * Test TraceListenerEx and multiple simultaneous trace listeners.
     *
     * @return false if we should abort the test; true otherwise
     */
    public boolean testCase2()
    {
        reporter.testCaseInit("Test TraceListenerEx and multiple simultaneous trace listeners");
        reporter.logWarningMsg("Note: limited validation: partly just a crash test so far.");

        try
        {
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer(testFileInfo.getXSLSource());

            TraceManager traceManager = ((TransformerImpl)transformer).getTraceManager();
            reporter.check((null != traceManager), true, "getTraceManager is non-null");
            reporter.logStatusMsg("traceManager.hasTraceListeners() is-0: " + traceManager.hasTraceListeners());

            LoggingTraceListener ltl = new LoggingTraceListener(reporter);
            LoggingPrintTraceListener ltl2 = new LoggingPrintTraceListener(reporter);
            LoggingTraceListenerEx ltl3 = new LoggingTraceListenerEx(reporter);
            
            
            reporter.logInfoMsg("Transformer created, addTraceListener(LoggingTraceListener)..."); 
            traceManager.addTraceListener((TraceListener)ltl);
            reporter.logStatusMsg("traceManager.hasTraceListeners() is-1: " + traceManager.hasTraceListeners());
            
            reporter.logInfoMsg("... and addTraceListener(LoggingPrintTraceListener)"); 
            traceManager.addTraceListener((TraceListener)ltl2);
            reporter.logStatusMsg("traceManager.hasTraceListeners() is-2: " + traceManager.hasTraceListeners());

            reporter.logInfoMsg("... and addTraceListener(LoggingTraceListenerEx)"); 
            traceManager.addTraceListener((TraceListener)ltl3);
            
            reporter.check(traceManager.hasTraceListeners(), true, "traceManager.hasTraceListeners() true after adding several");
         
            reporter.logInfoMsg("About to create output: " + outNames.nextName()); 
            transformer.transform(testFileInfo.getXMLSource(),
                                  new StreamResult(outNames.currentName()));
            reporter.checkPass("Crash test only: returned from transform() call");
            
            // Now ask each listener how many events it traced
            int[] tracedEvents = ltl.getCounters();
            reporter.logStatusMsg("Last event traced(LTL):" + ltl.getLast());
            reporter.logStatusMsg("Events traced(LTL):" + tracedEvents[LoggingTraceListener.TYPE_TRACE]
                                  + " events generated:" + tracedEvents[LoggingTraceListener.TYPE_GENERATED]
                                  + " events selected:" + tracedEvents[LoggingTraceListener.TYPE_SELECTED]);
            reporter.check(tracedEvents[LoggingTraceListener.TYPE_SELECTED], 3, 
                           "LTL Correct number of selected events for testfile " + testFileInfo.getDescription());
            
            int[] tracedEvents2 = ltl2.getCounters();
            reporter.logStatusMsg("Last event traced(LPTL):" + ltl2.getLast());
            reporter.logStatusMsg("Events traced(LPTL):" + tracedEvents2[LoggingPrintTraceListener.TYPE_TRACE]
                                  + " events generated:" + tracedEvents2[LoggingPrintTraceListener.TYPE_GENERATED]
                                  + " events selected:" + tracedEvents2[LoggingPrintTraceListener.TYPE_SELECTED]);
            reporter.check(tracedEvents2[LoggingTraceListener.TYPE_SELECTED], 3, 
                           "LPTL Correct number of selected events for testfile " + testFileInfo.getDescription());
            
            // For some reason this returns it's parent's class counter 
            //  array, not it's own...
            int[] tracedEvents3 = ltl3.getCounters();
            int selectedEndCtr = ltl3.getCounterEx();
            reporter.logStatusMsg("Last event traced(LTLE):" + ltl3.getLast());
            reporter.logStatusMsg("Events traced(LTLE):" + tracedEvents3[LoggingTraceListenerEx.TYPE_TRACE]
                                  + " events generated:" + tracedEvents3[LoggingTraceListenerEx.TYPE_GENERATED]
                                  + " events selected:" + tracedEvents3[LoggingTraceListenerEx.TYPE_SELECTED]
                                  + " events selectEnd:" + selectedEndCtr);
            reporter.check(tracedEvents3[LoggingTraceListenerEx.TYPE_SELECTED], 3, 
                           "LTLE Correct number of selected events for testfile " + testFileInfo.getDescription());
            
        }
        catch (Throwable t)
        {
            reporter.logThrowable(Logger.ERRORMSG, t, "testCase2 threw: ");
            reporter.checkFail("testCase2 threw: " + t.toString());
        }

        reporter.testCaseClose();
        return true;
    }


    /**
     * Test adding and removing multiple simultaneous trace listeners.
     *
     * @return false if we should abort the test; true otherwise
     */
    public boolean testCase3()
    {
        reporter.testCaseInit("Test adding and removing multiple simultaneous trace listeners");
        reporter.logWarningMsg("Note: limited validation: partly just a crash test so far.");

        try
        {
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer(testFileInfo.getXSLSource());

            TraceManager traceManager = ((TransformerImpl)transformer).getTraceManager();
            reporter.check((null != traceManager), true, "getTraceManager is non-null");
            reporter.check(traceManager.hasTraceListeners(), false, "traceManager.hasTraceListeners() false before adding");

            LoggingTraceListener ltl = new LoggingTraceListener(reporter);
            LoggingPrintTraceListener ltl2 = new LoggingPrintTraceListener(reporter);
            LoggingTraceListenerEx ltl3 = new LoggingTraceListenerEx(reporter);
            
            // Add one trace listener
            reporter.logInfoMsg("Transformer created, addTraceListener(LoggingTraceListener)..."); 
            traceManager.addTraceListener((TraceListener)ltl);
            reporter.check(traceManager.hasTraceListeners(), true, "traceManager.hasTraceListeners() true after adding1");

            // Remove one
            traceManager.removeTraceListener((TraceListener)ltl);
            //@todo Bugzilla#5140 comment out temporarily so smoketest passes 28-Nov-01 -sc
            // reporter.check(traceManager.hasTraceListeners(), false, "traceManager.hasTraceListeners() false after removing1");
            reporter.logWarningMsg("Bugzilla#5140 traceManager.hasTraceListeners() is (s/b:false) " + traceManager.hasTraceListeners());
            
            // Add multiple 
            traceManager.addTraceListener((TraceListener)ltl);
            reporter.check(traceManager.hasTraceListeners(), true, "traceManager.hasTraceListeners() true after adding1b");
            
            traceManager.addTraceListener((TraceListener)ltl2);
            reporter.check(traceManager.hasTraceListeners(), true, "traceManager.hasTraceListeners() true after adding2");

            traceManager.addTraceListener((TraceListener)ltl3);
            reporter.check(traceManager.hasTraceListeners(), true, "traceManager.hasTraceListeners() true after adding3");
            
            // Remove one
            traceManager.removeTraceListener((TraceListener)ltl2);
            reporter.check(traceManager.hasTraceListeners(), true, "traceManager.hasTraceListeners() true after adding3 removing1");

            // Remove all
            traceManager.removeTraceListener((TraceListener)ltl);
            traceManager.removeTraceListener((TraceListener)ltl3);
            //@todo Bugzilla#5140 comment out temporarily so smoketest passes 28-Nov-01 -sc
            // reporter.check(traceManager.hasTraceListeners(), false, "traceManager.hasTraceListeners() false after adding3 removing3");
            reporter.logWarningMsg("Bugzilla#5140 traceManager.hasTraceListeners() is (s/b:false) " + traceManager.hasTraceListeners());

            // Add one back and check transform
            traceManager.addTraceListener((TraceListener)ltl);
            reporter.check(traceManager.hasTraceListeners(), true, "traceManager.hasTraceListeners() true after adding1c");
         
            // Force trace listener to not bother logging, just capture statistics
            ltl.setLoggingLevel(100); // HACK - happens to be above 99, which is what we usually set max level tofs
            reporter.logInfoMsg("About to create output: " + outNames.nextName()); 
            transformer.transform(testFileInfo.getXMLSource(),
                                  new StreamResult(outNames.currentName()));
            reporter.checkPass("Crash test only: returned from transform() call");
            
            // Now ask each listener how many events it traced
            int[] tracedEvents = ltl.getCounters();
            reporter.logStatusMsg("Last event traced(LTL):" + ltl.getLast());
            reporter.logStatusMsg("Events traced(LTL):" + tracedEvents[LoggingTraceListener.TYPE_TRACE]
                                  + " events generated:" + tracedEvents[LoggingTraceListener.TYPE_GENERATED]
                                  + " events selected:" + tracedEvents[LoggingTraceListener.TYPE_SELECTED]);
            reporter.check(tracedEvents[LoggingTraceListener.TYPE_SELECTED], 3, 
                           "LTL Correct number of selected events for testfile " + testFileInfo.getDescription());
        }
        catch (Throwable t)
        {
            reporter.logThrowable(Logger.ERRORMSG, t, "testCase3-add/remove threw: ");
            reporter.checkFail("testCase3-add/remove threw: " + t.toString());
        }

        reporter.testCaseClose();
        return true;
    }


    /**
     * Test TraceListener with XalanProperties.SOURCE_LOCATION.
     *
     * @return false if we should abort the test; true otherwise
     */
    public boolean testCase4()
    {
        reporter.testCaseInit("Test TraceListener with XalanProperties.SOURCE_LOCATION");
        reporter.logWarningMsg("Note: limited validation: partly just a crash test so far.");

        try
        {
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer(testFileInfo.getXSLSource());

            TraceManager traceManager = ((TransformerImpl)transformer).getTraceManager();
            reporter.logTraceMsg("getTraceManager is:" + traceManager);

            LoggingTraceListener ltl = new LoggingTraceListener(reporter);
            ltl.setLoggingLevel(Logger.INFOMSG + 1);
            
            reporter.logInfoMsg("Transformer created, addTraceListener(LoggingTraceListener)..."); 
            traceManager.addTraceListener((TraceListener)ltl);
            
            // Verify new Xalan-J 2.x specific property as true (non-default value)
            reporter.logInfoMsg("About to run with Source Location Property ON"); 
            ((TransformerImpl)transformer).setProperty(XalanProperties.SOURCE_LOCATION, Boolean.TRUE);
            reporter.logInfoMsg("About to create output: " + outNames.nextName()); 
            transformer.transform(testFileInfo.getXMLSource(),
                                  new StreamResult(outNames.currentName()));
            reporter.logInfoMsg("Done creating output: " + outNames.currentName());

            int[] tracedEvents = ltl.getCounters();
            reporter.logStatusMsg("Last event traced(LPTL):" + ltl.getLast());
            reporter.logStatusMsg("Events traced(LPTL):" + tracedEvents[LoggingPrintTraceListener.TYPE_TRACE]
                                  + " events generated:" + tracedEvents[LoggingPrintTraceListener.TYPE_GENERATED]
                                  + " events selected:" + tracedEvents[LoggingPrintTraceListener.TYPE_SELECTED]);
            reporter.checkPass("Crash test: completed transformations with SOURCE_LOCATION just ON");
        }
        catch (Throwable t)
        {
            reporter.logThrowable(Logger.ERRORMSG, t, "testCase4a-XalanProperties.SOURCE_LOCATION threw: ");
            reporter.checkFail("testCase4a-XalanProperties.SOURCE_LOCATION threw: " + t.toString());
        }

        try
        {
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer(testFileInfo.getXSLSource());

            TraceManager traceManager = ((TransformerImpl)transformer).getTraceManager();
            reporter.logTraceMsg("getTraceManager is:" + traceManager);

            LoggingTraceListener ltl = new LoggingTraceListener(reporter);
            ltl.setLoggingLevel(Logger.INFOMSG + 1);
            
            reporter.logInfoMsg("Transformer created, addTraceListener(LoggingTraceListener)..."); 
            traceManager.addTraceListener((TraceListener)ltl);
            
            // Verify new Xalan-J 2.x specific property; false then true
            reporter.logInfoMsg("About to run with Source Location Property OFF"); 
            ((TransformerImpl)transformer).setProperty(XalanProperties.SOURCE_LOCATION, Boolean.FALSE);
            reporter.logInfoMsg("About to create output: " + outNames.nextName()); 
            transformer.transform(testFileInfo.getXMLSource(),
                                  new StreamResult(outNames.currentName()));
            reporter.logInfoMsg("Done creating output: " + outNames.currentName());

            int[] tracedEvents1 = ltl.getCounters();
            reporter.logStatusMsg("Last event traced(LPTL):" + ltl.getLast());
            reporter.logStatusMsg("Events traced(LPTL):" + tracedEvents1[LoggingPrintTraceListener.TYPE_TRACE]
                                  + " events generated:" + tracedEvents1[LoggingPrintTraceListener.TYPE_GENERATED]
                                  + " events selected:" + tracedEvents1[LoggingPrintTraceListener.TYPE_SELECTED]);

            ltl.reset();

            // Verify new Xalan-J 2.x specific property; false then true
            reporter.logInfoMsg("About to run with Source Location Property ON"); 
            ((TransformerImpl)transformer).setProperty(XalanProperties.SOURCE_LOCATION, Boolean.TRUE);
            reporter.logInfoMsg("About to create output: " + outNames.nextName()); 
            transformer.transform(testFileInfo.getXMLSource(),
                                  new StreamResult(outNames.currentName()));
            reporter.logInfoMsg("Done creating output: " + outNames.currentName());

            int[] tracedEvents2 = ltl.getCounters();
            reporter.logStatusMsg("Last event traced(LPTL):" + ltl.getLast());
            reporter.logStatusMsg("Events traced(LPTL):" + tracedEvents2[LoggingPrintTraceListener.TYPE_TRACE]
                                  + " events generated:" + tracedEvents2[LoggingPrintTraceListener.TYPE_GENERATED]
                                  + " events selected:" + tracedEvents2[LoggingPrintTraceListener.TYPE_SELECTED]);
            reporter.checkPass("Crash test: completed transformations with SOURCE_LOCATION OFF and ON");
        }
        catch (Throwable t)
        {
            reporter.logThrowable(Logger.ERRORMSG, t, "testCase4b-XalanProperties.SOURCE_LOCATION threw: ");
            reporter.checkFail("testCase4b-XalanProperties.SOURCE_LOCATION threw: " + t.toString());
        }

        reporter.testCaseClose();
        return true;
    }


    /**
     * 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 TraceListenerTest:\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)
    {
        TraceListenerTest app = new TraceListenerTest();
        app.doMain(args);
    }
}