Derby - Class org.apache.derbyTesting.functionTests.harness.RunTest

   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.

*/

    // For printing debug info

    static boolean verbose=false;

    // Under some circumstances, we may need to skip the test

    static boolean skiptest = false;

    static StringBuffer skiptestReason = new StringBuffer();

   

    //java requires / to look into jars, irrespective of OS

    static final String testResourceHome = "/org/apache/derbyTesting/functionTests/";

   

    // Framework support

    static String[] validFrameworks = {"embedded","",

               "DerbyNet","DerbyNetClient", "DB2jcc",

               "DB2app"};

    static NetServer ns;

    static boolean serverNeedsStopping = false; // used in controlling network server when useprocess=false:

    static boolean jvmnet = false; // switch to see if we need have client & server in a different jvm

    static String jvmnetjvm; // string for class name of server jvm if different from client jvm

    static String driverName;

    static String dbName;

    // Test properties

  static String jvmName = "currentjvm";

  static String javaCmd;

  static String javaVersion; // System.getProperty("java.version")

  static String majorVersion;

  static String minorVersion;

  static int jccMajor;

  static int jccMinor;

  static int imajor;

  static int iminor;

  static boolean isjdk12test = false;

  static String classpath = "";

  static String classpathServer = "";

    public static String framework = "embedded";

    public static String J9_STATEMENTCACHESIZE = "20";

    static String usesystem = "";

    static String searchCP = "";

    static boolean useCommonDB = false;

  static boolean keepfiles = false;

  static boolean useprocess = true;

  static boolean systemdiff = false; // can set true if there is a system diff

  static boolean upgradetest = false;

  static boolean encryption = false; // requires jdk12ext plus encryptionProtocol

  static boolean jdk12exttest = false; // requires jdk12ext

    static boolean generateUTF8Out = false; // setting to create a utf8 encoded master file.

  static String runningdir = ""; // where the tests are run and suppfiles placed

  static String outputdir = ""; // user can specify as a property (optional)

  static String canondir; // optional (to specify other than "master")

  static String bootcp; // for j9 bootclasspath

  static String canonpath; // special full path (will be platform dependent)

  static String mtestdir = ""; // for MultiTest user must specify testdir

  static String testSpecialProps = ""; // any special suite properties

  static String testJavaFlags = ""; // special command line flags

  static String jvmflags; // java special flags

  static boolean reportstderr = true;

  static int timeout = -1; // in case tests are hanging

  public static String timeoutStr;

  static String jarfile; // some tests have jar files (like upgrade)

  static boolean skipsed = false;

  static String commonDBHome = "testCSHome";

  static boolean dbIsNew = true;

  static String runwithjvm="true";

  static boolean startServer=true; // should test harness start the server

  static String hostName; // needs to be settable for ipv testing, localhost otherwise.)

  static String testEncoding; // Encoding used for child jvm and to read the test output

  static String upgradejarpath; // Encoding used for child jvm and to read the test output

  static boolean replacePolicyFile=false; // property used to see if we need to replace the default policy file or append to it.

  // Other test variables for directories, files, output

  static String scriptName = ""; // testname as passed in

  static String scriptFileName; // testname with extension

  static String testDirName = ""; // test directory name

        static String defaultPackageName = "/org/apache/derbyTesting/";

        static String javaPath = "org.apache.derbyTesting."; // for java tests

  static String testType; // sql, java, unit, etc.

  static String testBase; // testname without extension

  static String testOutName; // output name without path or extension (optional)

  static String passFileName; // file listing passed tests

  static String failFileName; // file listing failed tests

    static String UTF8OutName; // file name for utf8 encoded out - not used for file comparison

  static String tempMasterName; //file name for master, converted to local encoding, and for network server, corrected master

  static File passFile;

    static File failFile;

  static String shutdownurl = "";

    static boolean useOutput; // use output or assume .tmp file is produced?

    static boolean outcopy; // copy support files to outDir rather than runDir

  static String userdir; // current user directory

  static char fileSep; // file separator for the system

    static PrintWriter printWriter = null; // used to write test output to .tmp

    static PrintWriter pwDiff = null; // for writing test output and info

    static File script; // The file created for test files other than java tests

    static File baseDir; // the DB base system dir

    static boolean deleteBaseDir; // the DB base system dir

    static File outDir; // test out dir

    static File runDir; // where test is run and where support files are expected

    static File canonDir; // allows setting master dir other than default

    static File tmpOutFile; // tmp output file (before sed)

    static File tempMasterFile; // master file copied into local encoding - with networkserver, also processed

    static File stdOutFile; // for tests with useoutput false

    static File finalOutFile; // final output file (after sed)

    static File UTF8OutFile; // file name for out file copied into utf8 encoding

    static File appPropFile; // testname_app.properties or default

    static File clPropFile; // testname_derby.properties or default

    static File diffFile; // To indicate diffs

    static File tsuiteDir; // Final output dir for suite(s)

    static File rsuiteDir; // Where to report .pass and .fail for suite(s)

  static File extInDir;    //Where all external test input files exist.

  static File extOutDir;    //Where all external test input files exist.

  static File extInOutDir;    //Where all external test input files exist.

    // This test may be part of a suite

    // (RunTest may need to know this is a suite to avoid dup output like sysinfo)

    static String topsuitedir = ""; // in case of nested suites

    static String topsuiteName = "";

    static String topreportdir = "";

    static String suiteName = "";

    static boolean isSuiteRun = false;

    static boolean lastTestFailed = false;

    static boolean isI18N = false;

    /** The value of derby.ui.codeset if it has been specified in the

     * properties file. */

    static String codeset = null;

    static boolean junitXASingle = false;

   

    /**

     * Run the test without a security manager. Hopefully

     * should only be used in few cases. Though initially

     * may be used to bypass problematic tests and get the

     * remainder of the tests running with the security manager.

     */

    static boolean runWithoutSecurityManager;

    static InputStream isSed = null; // For test_sed.properties // Cliff

  public static void main(String[] args)

    throws Exception

  {

    Locale.setDefault(Locale.US);

    skiptestReason.setLength(0); // 0 out for useprocess

    // Determine the test type

    if (args.length == 0)

    {

      // No script name provided

      System.out.println("no test name provided");

      System.exit(1);

    }

    scriptName = args[0];

    if (Boolean.getBoolean("listOnly"))

    {

      System.out.println("LISTONLY :" + scriptName);

      return;

    }

    if ( (scriptName == null) || (scriptName.equals("")) )

    {

        System.out.println("Null or blank test script name.");

        System.exit(1);

    }

    // If useprocess=false RunList calls this main method with 7 arguments...

    if (args.length == 7)

    {

        defaultPackageName = args[1];

        usesystem = args[2];

        useprocess = false;

        shutdownurl = args[4];

        isSuiteRun = true;

        suiteName = args[5];

        //System.out.println("suiteName: " + suiteName);

        framework=args[6];       

        // initializing startServer to true (which it would be if we'd

        // run with useprocess=true) or network server will not get started

        startServer=true;       

    }

   

    testType = scriptName.substring(scriptName.lastIndexOf(".") + 1);

    verifyTestType();

        // Get the properties for the test

    Properties sp = System.getProperties();

    // For useprocess=false, some system wide properties need to be reset

    if (useprocess == false)

    {

        sp.put("useprocess", "false");

            // Reset maximumDisplayWidth because some tests set this in app properties

            // and when running in same process, can cause extra long lines and diffs

            if ( sp.getProperty("maximumDisplayWidth") == null )

                sp.put("maximumDisplayWidth", "128");

            if ( sp.getProperty("ij.defaultResourcePackage") != null )

                sp.put("ij.defaultResourcePackage", defaultPackageName);

            System.setProperties(sp);

        }

       

        JavaVersionHolder  jvhs = getProperties(sp);

    boolean        isJDBC4 = jvhs.atLeast( 1, 6 );

        // Setup the directories for the test and test output

        setDirectories(scriptName,sp);

        if (testDirName.startsWith("i18n")) {

            isI18N=true;

        }

        // Check for properties files, including derby.properties

        // and if needed, build the -p string to pass to the test

        AppsRequiredPassword creds = new AppsRequiredPassword();

        String propString = createPropString(creds);

        if ( (isSuiteRun == false) && (useprocess) )

        {

            SysInfoLog sysLog = new SysInfoLog();

            sysLog.exec(jvmName, javaCmd, classpath, framework, pwDiff, useprocess);

        }

      String startTime = CurrentTime.getTime();

      StringBuffer sb = new StringBuffer();

      sb.append("*** Start: " + testBase + " jdk" + javaVersion + " ");

      if ( (framework.length()>0) && (!framework.startsWith("embedded")) )

          sb.append(framework + " ");

      if ( (suiteName != null) && (suiteName.length()>0) )

          sb.append(suiteName + " ");

      sb.append(startTime + " ***");

      System.out.println(sb.toString());

      pwDiff.println(sb.toString());

            // Run the Server if needed

      if ((driverName != null) && (!skiptest) )

      {

            // before going further, get the policy file copied and if

            // needed, modify it with the test's policy file

            composePolicyFile();

            String spacedJvmFlags = jvmflags;

            // we now replace any '^' in jvmflags with ' '

            if ((jvmflags != null) && (jvmflags.indexOf("^")>0))

            {

                spacedJvmFlags = spaceJvmFlags(jvmflags);  

            }

           

            System.out.println("Initialize for framework: "+ framework );

            if (jvmnet && framework.startsWith("DerbyNet"))

            {

                // first check to see if properties were set to use a different jvm for server/client

                String jvmnetjvm = System.getProperty("serverJvmName");

                if (jvmnetjvm == null)

                {

                    // default to the latest one we know

                    jvmnetjvm = "j9_22";

                }

                ns = new NetServer(baseDir, jvmnetjvm, classpathServer, null,

                                   spacedJvmFlags,framework, startServer,

                                   creds.password);

            }

            else

                ns = new NetServer(baseDir, jvmName, classpathServer,

                                   javaCmd, spacedJvmFlags,framework,

                                   startServer, creds.password);

            //  With useprocess=true, we have a new dir for each test, and all files for

            // the test, including a clean database, go in that directory. So, network server

            // for each test runs in that dir, and stops when done. If the test's properties

            // file has startServer=false the test will handle start/stop, otherwise the harness

            // needs to start and stop the server.

            //  But with useprocess=false we're using the same directory and thus the same

            // database, so there's little point in bouncing the server for each test in a suite,

            // and it would slow the suite run.

            //  So, with useprocess=true, or if we're just running 1 test with useprocess=false,

            // start network server and set serverNeedsStopping=true to have it stopped later;

            // if useprocess=false and we're in a suite, start network server if it's not running

            // and leave serverNeedsStopping=false, unless startServer=false, then,

            // if network server is running, stop it.

            if ((!useprocess) && (isSuiteRun))

            {                

                boolean started = false;

                try

                {

                    started = ns.testNetworkServerConnection();

                }

                catch (Exception e) {} // ignore

                if (!started && startServer)

                    ns.start(); // start but don't stop, so not setting serverNeedsStopping

                if (started && !startServer)

                    ns.stop();

            }

            else

            {

                ns.start();

                serverNeedsStopping = true;

            }

        }

   

        // If the test has a jar file (such as upgrade) unjar it

        if (jarfile != null)

        {

            UnJar uj = new UnJar();

            uj.unjar(jarfile, outDir.getCanonicalPath(), true);

        }

       

        // Run the actual test (unless skiptest was set to true)

        if (skiptest == false)

        {

            testRun(propString, sp);

        }

        else

        {

      if (skiptestReason.length() == 0)

        addSkiptestReason("Test skipped: skiptest set without setting skiptestReason, please fix RunTest.java...");

        pwDiff.println(skiptestReason);

        System.out.println(skiptestReason);

            doCleanup(javaVersion);

            return;

        }

           

        // Stop the Network server if necessary

    if (serverNeedsStopping)

    {

        ns.stop();

    }

    // Do "sed" to strip some unwanted stuff from the output file

    // unless flag skipsed is set to true (for special cases)

   

    String outName = finalOutFile.getPath();

        if (skipsed)

        {

            tmpOutFile.renameTo(finalOutFile);

        }

        else

        {

                    try

                    {

                        Sed sed = new Sed();

                        sed.exec(tmpOutFile,finalOutFile, isSed,

                                        NetServer.isClientConnection(framework), isI18N, isJDBC4);

        }

        catch (ClassFormatError cfe)

        {

            if (verbose) System.out.println("SED Error: " + cfe.getMessage());

        }

        }

        // Now do a diff between the out and the master files

      // Use the system's diff if systemdiff is true

      String frameworkMaster = framework;

      if (framework.startsWith("embedded"))

          frameworkMaster = "";

      FileCompare diff = new FileCompare();

        if (verbose)

        {

            System.out.println(

                "About to execute: diff.exec(" +

                " outName = "           + outName +

                ",outDir = "            + outDir  +

                ",pwDiff = "            + pwDiff  +

                ",testOutName = "       + testOutName +

                ",frameworkMaster = "   + frameworkMaster +

                ",jvmName = "           + jvmName +

                ",iminor = "            + iminor  +

                ",useprocess = "        + useprocess +

                ",systemdiff = "        + systemdiff +

                ",canondir = "          + canondir +

                ",canonpath = "         + canonpath +

                ")\n");

        }

      boolean status;

      // allow for server jvmName to be different from client jvmName

      if (jvmnet)

      {

            // first check to see if properties were set to use a different jvm for server/client

            if (jvmnetjvm == null)

            {

                // default to the latest one we know

                jvmnetjvm = "j9_22";

            }

          status = diff.exec(outName, outDir, pwDiff, testOutName,

            frameworkMaster, jvmName, iminor, useprocess, systemdiff, canondir,

          canonpath, jvmnetjvm);

        }

      else

            status = diff.exec(outName, outDir, pwDiff, testOutName,

            frameworkMaster, jvmName, iminor, useprocess, systemdiff, canondir,

          canonpath, null);

      if (status == true)

      {

        lastTestFailed = true;

        pwDiff.println("Test Failed.");

        System.out.println("Test Failed.");

        keepfiles = true;

        addToFailures(scriptName);

        if (useCommonDB) {

          status = baseDir.delete();

        }

        }

        else

      {

      addToSuccesses(scriptName);

        pwDiff.flush();

        }

        generateUTF8OutFile(finalOutFile);

       

    // Cleanup files

    doCleanup(javaVersion);

  }

    private static void testRun(String propString, Properties sysProp)

        throws FileNotFoundException, IOException, Exception

    {

        String systemHome = baseDir.getPath();

        String scriptPath = null;

        if (testType.startsWith("sql"))

            scriptPath = script.getPath();

               

      // cleanup for all tests that re-use standard testCSHome/wombat database

      if (useCommonDB == true

        && (usesystem == null || usesystem == "")

        && (testType.equals("sql") || testType.equals("java")

      || testType.equals("sql2"))) {

          dbcleanup.doit(dbIsNew);

      }

 

        // Create a process to execute the command unless useprocess is false

        if ( useprocess )

    {

            // Build the test command

            String[] testCmd =

            buildTestCommand(propString, systemHome, scriptPath);

            execTestProcess(testCmd);

    }

        else

    {

            execTestNoProcess(sysProp, systemHome, propString, scriptPath);

    }

    }

    /** This is the method which created directories and looks for script file,

     * need to make OS specific paths here.

     *

     */

    private static void setDirectories(String scriptName, Properties sp)

        throws ClassNotFoundException, FileNotFoundException, IOException

    {

        // Get the current userdir

        userdir = sp.getProperty("user.dir");

       

        // reset defaultPackageName (for useprocess=false)

        if (useprocess == false)

          defaultPackageName = "/org/apache/derbyTesting/";

           

        // reset defaultPackageName (for useCommonDB=true)

        if (useCommonDB == true)

        {

            defaultPackageName = "/org/apache/derbyTesting/";

        }

           

        // Set the resourceName from the default

        // If not set by user, the default is used

        String resourceName = defaultPackageName + "functionTests/tests/";

        // scriptName could be of these two formats:

        // testdir/test.testtype (testtype is sql, java, etc.)

        // test.testtype (where the defaultPackageName includes the testdir)

        int index = scriptName.lastIndexOf('/');

        if (index == -1) // no test directory was specified

        {

            if ( (!testType.equals("sql")) && (!testType.equals("java")) && (!testType.equals("junit")))

            {

                System.out.println("Test argument should be of the form: <dir>/<test>.<ext>");

                System.exit(1);

            }

            else

            {

                scriptFileName = scriptName; // such as my.sql

                resourceName += scriptName; // build the full resource name

            }

        }

        else // the testdir was specified

        {

            testDirName = (index==0)?"":scriptName.substring(0,index);

            //System.out.println("testDirName: " + testDirName);

            scriptFileName = scriptName.substring(index+1, scriptName.length());