text: /*
   * 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.
   */
  // Base header file.  Must be first.
  #include <xalanc/Include/PlatformDefinitions.hpp>
  
  
  
  #include <cstdio>
  
  #if defined(XALAN_CLASSIC_IOSTREAMS)
  #include <iostream.h>
  #else
  #include <iostream>
  #endif
  
  // This is here for memory leak testing. 
  #if !defined(NDEBUG) && defined(_MSC_VER)
  #include <crtdbg.h>
  #endif
  
  
  
  #include <xercesc/util/PlatformUtils.hpp>
  
  
  
  #include <xalanc/PlatformSupport/XalanUnicode.hpp>
  
  
  
  #include <xalanc/XSLT/XSLTInputSource.hpp>
  #include <xalanc/XSLT/XSLTResultTarget.hpp>
  
  
  
  #include <xalanc/XalanTransformer/XalanTransformer.hpp>
  
  
  
  #include <xalanc/Harness/XalanXMLFileReporter.hpp>
  #include <xalanc/Harness/XalanFileUtility.hpp>
  
  
  
  XALAN_USING_STD(cerr)
  XALAN_USING_STD(cout)
  XALAN_USING_STD(endl)
  
  
  
  XALAN_USING_XALAN(XalanFileUtility)
  XALAN_USING_XALAN(XalanDOMString)
  
  
  
  void
  setHelp(XalanFileUtility&   h)
  {
      h.args.getHelpStream() << endl
           << "params dirname [-out]"
           << endl
           << endl
           << "dirname        (base directory for \'capi\' testcases)"
           << endl
           << "-out dirname   (base directory for output)"
           << endl;
  }
  
  
  
  //  This function returns the testcase number.  All of these tests are called
  //  params0X, and there are only 6 of them,  so we can pick off the
  //  second X to determine what test number we're dealing with.  We need to
  //  know which test because each test gets different parameters. This code will
  //  need modification if the number of tests changes.
  int
  getTestNumber(const XalanDOMString&     theFile)
  {
      assert(8 < theFile.length());
  
      return theFile[7] - XALAN_CPP_NAMESPACE_QUALIFIER XalanUnicode::charDigit_0;
  }
  
  
  
  int
  runTests(
              int     argc,
              char*   argv[])
  {
      int             theResult = 0;
  
      XalanFileUtility    h;
  
      char testCase[15];
      XalanDOMString fileName, theGoldFile;
      const XalanDOMString  currentDir("params");
  
      // Set the program help string,  then get the command line parameters.
      //
      setHelp(h);
  
      // Get the command line parameters.
      //
      if (h.getParams(argc, argv, "PARAMS-RESULTS") == true)
      {
          const XalanDOMString    extDir(h.args.base + currentDir);
  
          // Check that the base directory is correct.
          if ( !h.checkDir(extDir) )
          {
              cout << "Invalid base directory - " << extDir << endl;
              cout << h.args.getHelpMessage();
  
              theResult = -1;
          }
          else
          {
              XALAN_USING_XALAN(XalanTransformer)
              XALAN_USING_XALAN(XalanXMLFileReporter)
  
              XalanTransformer    xalan;
  
              // Generate Unique Run id. (Only used to name the result logfile.)
              const XalanDOMString    UniqRunid = h.generateUniqRunid();
  
              // Defined basic constants for file manipulation
              const XalanDOMString    drive(h.getDrive());
              const XalanDOMString    resultFilePrefix("params");
              const XalanDOMString    resultsFile(drive + h.args.output + resultFilePrefix + UniqRunid + XalanFileUtility::s_xmlSuffix);
              
              XalanXMLFileReporter        logFile(resultsFile);
  
              logFile.logTestFileInit("Param Testing: Testing ability to pass parameters to stylesheets. ");
  
              try
              {
                  bool embedFlag =  false;
                      
                  // Get the files found in the "params" directory
                  const XalanDOMString  theOutputDir = h.args.output + currentDir;
  
                  // Check that output directory is there.
                  h.checkAndCreateDir(theOutputDir);
  
                  typedef XalanFileUtility::FileNameVectorType        FileNameVectorType;
  
                  const FileNameVectorType    files = h.getTestFileNames(h.args.base, currentDir, true);
                  logFile.logTestCaseInit(currentDir);
  
                  for(FileNameVectorType::size_type i = 0; i < files.size(); ++i)
                  {
                      fileName = files[i];
                      sprintf(testCase, "%s%d","TestCase",i+1);
                      h.data.testOrFile = testCase;
  
                      // Set up the input/output files.
                      const XalanDOMString  theXSLFile= h.args.base + currentDir + XalanFileUtility::s_pathSep + fileName;
                      XalanDOMString        theXMLFile;
                      
                      // Neither testcase 7 nor 8 utilize xml source files. Both use fragment identifiers,
                      // so the generation of xml file is unnecessary.
                      // Testcase 7 tests: <?xml-stylesheet type="text/xsl" href="#style1-23.34.123456789_345"?>
                      // Testcase 8 tests: <?xml-stylesheet type="text/xsl" href="foo.xsl"?>
                      if ( i+1 <= 6 )
                      {
                          theXMLFile = h.generateFileName(theXSLFile, "xml");
                      }
  
                      h.data.xmlFileURL = theXMLFile;
                      h.data.xslFileURL = theXSLFile;
  
                      const XalanDOMString  theOutput =  h.args.output + currentDir + XalanFileUtility::s_pathSep + fileName; 
                      const XalanDOMString  theOutputFile = h.generateFileName(theOutput, "out");
                      theGoldFile = h.args.gold + currentDir + XalanFileUtility::s_pathSep + fileName;
                      theGoldFile = h.generateFileName(theGoldFile, "out");
  
                      XALAN_USING_XALAN(XSLTResultTarget);
                      XALAN_USING_XALAN(XSLTInputSource);
  
                      const XSLTResultTarget  theResultTarget(theOutputFile);
                      const XSLTInputSource   xslInputSource(theXSLFile);
                      const XSLTInputSource   xmlInputSource(theXMLFile);
                              
                      // Set the desired parameters
                      switch (getTestNumber(fileName))
                      {   
                          case 2:
                              xalan.setStylesheetParam("in1", "'A '");
  
                              xalan.setStylesheetParam("in2", "'B '");
  
                              xalan.setStylesheetParam(
                                  XalanDOMString("in3"),
                                  XalanDOMString("'C '"));
                              xalan.setStylesheetParam(
                                  XalanDOMString("in4"),
                                  XalanDOMString("'D '"));
                              xalan.setStylesheetParam(
                                  XalanDOMString("in5"),
                                  XalanDOMString("'E '"));
                              break;
  
                          case 3:
                              xalan.setStylesheetParam(
                                  XalanDOMString("'xyz:in1'"),
                                  XalanDOMString("'DATA'"));
                              break;
  
                          case 7:
                              {
                                  const XSLTInputSource   embed07InputSource(theXSLFile);
                                  xalan.transform(embed07InputSource, theResultTarget);
                                  h.data.testOrFile += " (Embed01)";
                                  embedFlag = true;
                                  break;
                              }
  
                          case 8:
                              {
                                  const XSLTInputSource   embed08InputSource(theXSLFile);
                                  xalan.transform(embed08InputSource, theResultTarget);
                                  h.data.testOrFile += " (Embed02)";
                                  embedFlag = true;
                                  break;
                              }
                          default:
                              xalan.setStylesheetParam(
                                  XalanDOMString("input"),
                                  XalanDOMString("'testing 1 2 3'"));
                              break;
                      }
  
                      // Do a total end to end transform with no pre parsing of either xsl or xml files.
                      if (!embedFlag)
                      {
                          xalan.transform(xmlInputSource, xslInputSource, theResultTarget);
                      }
  
                      // Check and report the results.
                      h.checkResults(theOutputFile, theGoldFile, logFile);
                  }
                                  
                  logFile.logTestCaseClose("Done", "Pass");
              }
              catch(...)
              {
                  cerr << "Exception caught!!!" << endl << endl;
  
                  theResult = -1;
              }
  
              h.reportPassFail(logFile, UniqRunid);
              logFile.logTestFileClose("Param Testing: ", "Done");
              logFile.close();
  
              h.analyzeResults(xalan, resultsFile);
          }
      }
  
      return theResult;
  }
  
  
  
  int
  main(
              int     argc,
              char*   argv[])
  {
  #if !defined(NDEBUG) && defined(_MSC_VER)
      _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
      _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
      _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
  #endif
  
      int theResult = 0;
  
      try
      {
          XALAN_USING_XERCES(XMLPlatformUtils)
  
          XALAN_USING_XALAN(XalanTransformer)
  
          // Call the static initializers for xerces and xalan, and create a transformer
          //
          XMLPlatformUtils::Initialize();
  
          XalanTransformer::initialize();
  
          theResult = runTests(argc, argv);
  
          XalanTransformer::terminate();
  
          XMLPlatformUtils::Terminate();
  
          XalanTransformer::ICUCleanUp();
      }
      catch(...)
      {
          cerr << "Initialization failed!" << endl << endl;
  
          theResult = -1;
      }
  
      return theResult;
  }
  