/*

  * Copyright 1999-2001,2004 The Apache Software Foundation.

  * 

  * 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.

  */

 package org.apache.commons.latka.junit;

 // java imports

 import java.io.File;

 import java.io.IOException;

 import java.net.MalformedURLException;

 import java.net.URL;

 // jaxp imports

 import javax.xml.parsers.FactoryConfigurationError;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.parsers.SAXParser;

 import javax.xml.parsers.SAXParserFactory;

 // latka imports

 import org.apache.commons.latka.DefaultLatkaEventInfo;

 import org.apache.commons.latka.Latka;

 import org.apache.commons.latka.LatkaException;

 import org.apache.commons.latka.Suite;

 // log4j imports

 import org.apache.log4j.Category;

 // sax imports

 import org.xml.sax.Attributes;

 import org.xml.sax.InputSource;

 import org.xml.sax.SAXException;

 import org.xml.sax.XMLReader;

 import org.xml.sax.helpers.DefaultHandler;

 // junit imports

 import junit.framework.Test;

 import junit.framework.TestResult;

 /**

  * A JUnit {@link junit.framework.Test Test} which is created by

  * wrapping a Latka {@link org.apache.commons.latka.Suite Suite}

  *

  * @author Chuck Burdick

  * @author dIon Gillard

  * @version $Id: JUnitTestAdapter.java 155424 2005-02-26 13:09:29Z dirkv $

  */

 public class JUnitTestAdapter implements Test {

     /** log4j category that output is logged to */

     private static final Category _log = Category.getInstance(

         JUnitTestAdapter.class);

     /** The latka {@link org.apache.commons.latka.Suite Suite} to be run*/

     private Suite _latkaSuite = null;

     /** the number of tests in the suite */

     private int _testCount = 0;

     /**

      * Create a Test from a Latka suite and a number of tests

      *

      * @param suite The Latka {@link org.apache.commons.latka.Suite}

      * to be run as a JUnit Test

      * @param testCount The number of 'request's in the Latka suite

      */   

     protected JUnitTestAdapter(Suite suite, int testCount) {

         _latkaSuite = suite;

         _testCount = testCount;

     }

     /**

      * Create a Test from a Latka file

      * @param fileName The name of a readable file in Latka's XML format

      * @return a JUnit Test, ready to run, or null if the file can't be resolved

      */   

     public static Test createTestFromFile(String fileName) {

         Test result = null;

         File file = new File(fileName);

         if (file.exists()) {

             result = createTestFromFile(file);

         } else {

             _log.debug("Input file " + file.getAbsolutePath()

                 + " does not exist");

         }

         return result;

     }

     /**

      * Create a Test from a {@link java.io.File Java file}

      * @param file A readable java file containing Latka's XML format 

      * @return a JUnit Test, ready to run, or null if the file can't be resolved

      */   

     public static Test createTestFromFile(File file) {

         Test result = null;

         try {

             result = createTestFromURL(file.toURL());

         } catch (MalformedURLException e) {

             _log.debug("Could not access input file", e);

         }

         return result;

     }

     /**

      * Create a Test from a resource accessible via

      * the {@link java.lang.ClassLoader#getResource(String) class loader}

      * @param resourceName A resource accessible by the class loader in Latka's

      *      XML format

      * @return a JUnit Test, ready to run, or null if the resource can't be

      *      resolved

      */   

     public static Test createTestFromResource(String resourceName) {

         Test result = null;

         ClassLoader loader = JUnitTestAdapter.class.getClassLoader();

         URL resource = loader.getResource(resourceName);

         if (resource != null) {

             result = createTestFromURL(resource);

         }

         return result;

     }

     /**

      * Create a Test from a String containing a URL whose

      * contents are in Latka's XML format

      * @param url the {@link java.net.URL URL} to fetch

      * @return a JUnit Test, ready to run, or null if the url can't be resolved

      */   

     public static Test createTestFromURL(String url) {

         Test result = null;

         try {

             result = createTestFromURL(new URL(url));

         } catch (MalformedURLException e) {

             _log.debug("Unable to create URL " + url, e);

         }

         return result;

     }

     /**

      * Create a Test from a URL whose contents are in Latka's XML format

      * @param url the {@link java.net.URL URL} to fetch

      * @return a JUnit Test, ready to run, or null if the url can't be resolved

      */   

     public static Test createTestFromURL(URL url) {

         Test result = null;

         try {

             InputSource source = new InputSource(url.toString());

             Suite suite = new Suite(url);

             result = new JUnitTestAdapter(suite, parse(source));

         } catch (IOException ioe) {

             _log.debug("IOException obtaining xml from URL " + url, ioe);

         } catch (SAXException se) {

             _log.debug("Problem parsing URL " + url, se);

         } catch (ParserConfigurationException pce) {

             _log.debug("Problem determining parser", pce);

         }

         return result;

     }

     /**

      * Parse the Latka XML document to count the requests

      * @param xml The inputsource to parse

      * @throws IOException When an IO occurs reading the document

      * @throws SAXException When the document is invalid XML 

      * @throws FactoryConfigurationError When the SAX Parser factory can't be 

      *      configured correctly

      * @throws ParserConfigurationException When the SAX Parser can't be 

      *      configured correctly

      * @return the number of tests in the Latka suite

      */   

     protected static int parse(InputSource xml) throws IOException, SAXException

         , FactoryConfigurationError, ParserConfigurationException {

         int result = 0;

         XMLReader reader = null;

         SAXParserFactory factory = SAXParserFactory.newInstance();

         factory.setValidating(false);   

         SAXParser parser = factory.newSAXParser();

         reader = parser.getXMLReader();

         TestCounter handler = new TestCounter();

         reader.setContentHandler(handler);

         reader.parse(xml);

         result = handler.getCount();

         return result;

     }

     /**

      * A SAX Handler to count the number of request tags in the document

      *

      * @author Chuck Burdick

      * @author dIon Gillard

      * @version 

      * $Id: JUnitTestAdapter.java 155424 2005-02-26 13:09:29Z dirkv $

      */

     private static class TestCounter extends DefaultHandler {

         /** number of requests (ie junit tests) */

         private int _count = 0;

         /**

          * Create a DefaultHandler to count request elements

          */      

         public TestCounter() {

             _count = 0;

         }

         /**

          * process the start of an xml element

          * @param uri uri

          * @param localName localName

          * @param qName qName

          * @param atts atts

          */      

         public void startElement(String uri, String localName, String qName, 

                                  Attributes atts) {

             if (qName.equals("request")) {

                 _count++;

             }

         }

         /**

          * Provides the number of <request> tags

          * @return the count of request elements found

          */      

         public int getCount() {

             return _count;

         }

     }

     /**

      * Provides access, post-parsing, of the number of

      * request elements in the Latka Suite 

      * @return the number of test cases in the Latka suite

      */

     public int countTestCases() {

         return _testCount;

     }

     /**

      * Run the test, adding results to the provided 

      * {@link junit.framework.TestResult TestResult}

      *

      * @param r TestResult to accumulate

      */      

     public void run(TestResult r) {

         _log.debug("Attempting to perform latka tests");

         Latka latka = new Latka();

         try {

             latka.runTests(_latkaSuite, new DefaultLatkaEventInfo(new JUnitEventReporter(r)));

         } catch (LatkaException e) {

             _log.error("Unable to execute latka tests", e);

         }

     }

 }