qadevOOo/runner/complexlib/ComplexTestCase.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18 package complexlib;
  19
  20 import java.lang.reflect.Method;
  21 import share.DescEntry;
  22 import lib.TestParameters;
  23 import lib.StatusException;
  24 import share.LogWriter;
  25 import share.ComplexTest;
  26 import java.io.PrintWriter;
  27
  28 /**
  29  * Base class for all complex tests.
  30  */
  31 public abstract class ComplexTestCase extends Assurance implements ComplexTest
  32 {
  33
  34     /** The test parameters **/
  35     protected TestParameters param = null;
  36     /** Log writer **/
  37     protected LogWriter log = null;
  38     /**
  39      * The method name which will be written into f.e. the data base
  40      **/
  41     private String mTestMethodName = null;
  42
  43     private boolean m_bBeforeCalled;
  44
  45     /**
  46      * is called before the real test starts
  47      */
  48     private void before()
  49     {
  50         try
  51         {
  52             Method before = this.getClass().getMethod("before", new Class[] {} );
  53             before.invoke(this, new Object[] {} );
  54
  55             m_bBeforeCalled = true;
  56         }
  57         catch (java.lang.NoSuchMethodException e)
  58         {
  59             m_bBeforeCalled = true;
  60         }
  61         catch (java.lang.IllegalAccessException e)
  62         {
  63             log.println("Cannot access the 'before()' method, although it" + " is there. Is this ok?");
  64         }
  65         catch (java.lang.reflect.InvocationTargetException e)
  66         {
  67             Throwable t = e.getTargetException();
  68             if (!(t instanceof RuntimeException) || bSuccessful)
  69             {
  70                 log.println(t.toString());
  71                 if (message == null)
  72                 {
  73                     message = "Exception in before() method.\n\r" + t.getMessage();
  74                 }
  75                 bSuccessful = false;
  76                 t.printStackTrace((PrintWriter) log);
  77             }
  78         }
  79
  80     }
  81
  82     /** Description entry **/
  83
  84     private void test_method(DescEntry _entry)
  85     {
  86
  87         /* Maximal time one method is allowed to execute
  88          * Can be set with parameter 'ThreadTimeOut'
  89          **/
  90         int nThreadTimeOut = param.getInt("ThreadTimeOut");
  91         if (nThreadTimeOut == 0)
  92         {
  93             nThreadTimeOut = 300000;
  94         }
  95
  96         for (int i = 0; i < _entry.SubEntries.length; i++)
  97         {
  98
  99             DescEntry subEntry = _entry.SubEntries[i];
 100             if (m_bBeforeCalled)
 101             {
 102                 bSuccessful = true;
 103                 message = "";
 104             }
 105             else
 106             {
 107                 // set all test methods on failed, if 'before()' did not work.
 108                 subEntry.State = message;
 109                 subEntry.hasErrorMsg = true;
 110                 subEntry.ErrorMsg = message;
 111                 continue;
 112             }
 113             Method testMethod = null;
 114             try
 115             {
 116                 String entryName = subEntry.entryName;
 117                 Object[] parameter = null;
 118
 119                 int posLeftParenthesis = entryName.indexOf('(');
 120                 if (posLeftParenthesis != -1)
 121                 {
 122                     String sParameter = entryName.substring(posLeftParenthesis + 1, entryName.indexOf(')'));
 123                     mTestMethodName = entryName;
 124                     parameter = new String[] { sParameter };
 125                     entryName = entryName.substring(0, posLeftParenthesis);
 126                     testMethod = this.getClass().getMethod(entryName, new Class[] { String.class });
 127                 }
 128                 else
 129                 {
 130                     testMethod = this.getClass().getMethod(entryName, new Class[] {} );
 131                     mTestMethodName = entryName;
 132                 }
 133
 134                 MethodThread th = new MethodThread(testMethod, this, parameter, (java.io.PrintWriter) log);
 135                 log.println("Starting " + mTestMethodName);
 136                 th.start();
 137
 138                 try
 139                 {
 140                     // some tests are very dynamic in their execution time so that
 141                     // a threadTimeOut fails. In this cases the logging mechanism
 142                     // is a useful way to detect that an office respective a test
 143                     // is running and not death.
 144                     // But way ThreadTimeOut?
 145                     // There exists a complex test which uses no office. Therefore
 146                     // a logging mechanism to detect a stalled test.
 147                     int lastPing = -1;
 148                     int newPing = 0;
 149
 150                     int sleepingStep = 1000;
 151                     int factor = 0;
 152
 153                     while (th.isAlive() && (lastPing != newPing || factor * sleepingStep < nThreadTimeOut))
 154                     {
 155                         Thread.sleep(sleepingStep);
 156                         factor++;
 157                         // if a test starts the office itself it the watcher is a
 158                         // new one.
 159                         share.Watcher ow = (share.Watcher) param.get("Watcher");
 160                         if (ow != null)
 161                         {
 162                             lastPing = newPing;
 163                             newPing = ow.getPing();
 164                             factor = 0;
 165                         }
 166                     }
 167                 }
 168                 catch (InterruptedException e)
 169                 {
 170                 }
 171                 if (th.isAlive())
 172                 {
 173                     log.println("Destroy " + mTestMethodName);
 174                     th.stopRunning();
 175                     subEntry.State = "Test did sleep for " + (nThreadTimeOut / 1000) + " seconds and has been killed!";
 176                     subEntry.hasErrorMsg = true;
 177                     subEntry.ErrorMsg = subEntry.State;
 178                     continue;
 179                 }
 180                 else
 181                 {
 182                     log.println("Finished " + mTestMethodName);
 183                     if (th.hasErrorMessage())
 184                     {
 185                         subEntry.State = th.getErrorMessage();
 186                         subEntry.hasErrorMsg = true;
 187                         subEntry.ErrorMsg = subEntry.State;
 188                         continue;
 189                     }
 190                 }
 191             }
 192             catch (java.lang.Exception e)
 193             {
 194                 log.println(e.getClass().getName());
 195                 String msg = e.getMessage();
 196                 log.println("Message: " + msg);
 197                 e.printStackTrace((PrintWriter) log);
 198                 subEntry.State = "SKIPPED.FAILED";
 199                 subEntry.hasErrorMsg = true;
 200                 subEntry.ErrorMsg = (msg == null ? "" : msg);
 201                 continue;
 202             }
 203             subEntry.State = (bSuccessful ? "COMPLETED.OK" : message);
 204             subEntry.hasErrorMsg = !bSuccessful;
 205             subEntry.ErrorMsg = message;
 206         }
 207     }
 208
 209     /**
 210      * after() is called after the test is done
 211      */
 212     private void after()
 213     {
 214         if (m_bBeforeCalled)
 215         {
 216             // the after() method
 217             try
 218             {
 219                 Method after = this.getClass().getMethod("after", new Class[] {});
 220                 after.invoke(this, new Object[] {} );
 221             }
 222             catch (java.lang.NoSuchMethodException e)
 223             {
 224                 // simply ignore
 225             }
 226             catch (java.lang.IllegalAccessException e)
 227             {
 228                 // simply ignore
 229             }
 230             catch (java.lang.reflect.InvocationTargetException e)
 231             {
 232                 Throwable t = e.getTargetException();
 233                 if (!(t instanceof StatusException))
 234                 {
 235                     log.println(t.toString());
 236                     if (message == null)
 237                     {
 238                         message = "Exception in after() method.\n\r" + t.getMessage();
 239                     }
 240                     else
 241                     {
 242                         message += "Exception in \'after()\' method.\n\r" + t.getMessage();
 243                     }
 244                     log.println("Message: " + message);
 245                     t.printStackTrace((PrintWriter) log);
 246                 }
 247             }
 248         }
 249
 250     }
 251
 252
 253
 254     /**
 255      * Call test. It is expected, that an environment is
 256      * given to this test.
 257      *
 258      * @param entry The name of the test method that should be called.
 259      * @param environment The environment for the test.
 260      */
 261     public void executeMethods(DescEntry entry, TestParameters environment)
 262     {
 263         m_bBeforeCalled = false;
 264
 265         // get the environment
 266         param = environment;
 267         log = entry.Logger;
 268
 269
 270         // start with the before() method
 271         before();
 272
 273         //executeMethodTests
 274         test_method(entry);
 275
 276         // cleanup
 277         after();
 278     }
 279
 280
 281     /**
 282      * Implement this method in the Complex test.
 283      * @return All test method names.
 284      */
 285     public abstract String[] getTestMethodNames();
 286
 287     /**
 288      * Return a name for the test or tested object.
 289      * Override to give an own name.
 290      * @return As default, the name of this class.
 291      */
 292     public String getTestObjectName()
 293     {
 294         return this.getClass().getName();
 295     }
 296 }