qadevOOo/runner/lib/TestCase.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 package lib;
  29
  30 import java.io.PrintWriter;
  31
  32 import lib.TestParameters;
  33 /**
  34  * <code>TestCase</code> represent a factory for <code>TestEnvironment</code>s
  35  * creation and disposing for a given implementation object. The
  36  * <code>TestEnvironment</code> contains an instance of the implementation
  37  * object and all additional objects needed to perform tests on the object.
  38  *
  39  * <p>The <code>TestCase</code> provides four methods for its subclasses to
  40  * define its functionality: <code>initialize()</code>, <code>cleanup()</code>,
  41  * <code>createTestEnvironment()</code> and <code>disposeTestEnvironment()</code>.
  42  * The first two are intended to initialize and cleanup common objects shared
  43  * among all instances of <code>TestEnvironment</code> produced by the
  44  * <code>TestCase</code>, and they are called at the beginning and at the end of
  45  * the <code>TestCase</code> lifecycle accordingly.
  46  *
  47  * <p>The other two are intended to produce and dispose
  48  * <code>TestEnvironment</code> instances. The
  49  * <code>createTestEnvironment()</code> is called to create a
  50  * <code>TestEnvironment</code> instance and the
  51  * <code>disposeTestEnvironment()</code> is called when the instane is not used
  52  * anymore.
  53  *
  54  * @see lib.TestEnvironment
  55  */
  56 public abstract class TestCase {
  57
  58     /**
  59      * Specifies the PrintWriter to log information.
  60      */
  61     public PrintWriter log;
  62
  63     //public static TestCase tCase;
  64
  65     /**
  66      * Sets the log to write information during testing.
  67      */
  68     public void setLogWriter( PrintWriter log ) {
  69         this.log = log;
  70     }
  71
  72     /**
  73      * Initializes the <code>TestCase</code>. Calls <code>initialize()</code>
  74      * method.
  75      *
  76      * @param tParam test parameters.
  77      */
  78     public void initializeTestCase( TestParameters tParam ) {
  79         initialize( tParam, log );
  80     }
  81
  82     /**
  83      * Called while the <code>TestCase</code> initialization. In the
  84      * implementation does nothing. Subclasses can override to initialize
  85      * objects shared among all <code>TestEnvironment</code>s.
  86      *
  87      * @param tParam test parameters
  88      * @param log writer to log information while testing
  89      *
  90      * @see #initializeTestCase()
  91      */
  92     protected void initialize( TestParameters tParam, PrintWriter log ) {
  93     }
  94
  95
  96     /**
  97      * Cleans up the <code>TestCase</code>. Calls <code>cleanup()</code>.
  98      *
  99      * @param tParam test parameters
 100      */
 101     public void cleanupTestCase( TestParameters tParam ) {
 102         cleanup( tParam, log );
 103     }
 104
 105     /**
 106      * Called while the <code>TestCase</code> cleanup. In the implementation
 107      * does nothing. Subclasses can override to cleanup objects shared among
 108      * all <code>TestEnvironment</code>s.
 109      *
 110      * @param tParam test parameters
 111      * @param log writer to log information while testing
 112      *
 113      * @see #cleanupTestCase
 114      */
 115     protected void cleanup( TestParameters tParam, PrintWriter log ) {
 116     }
 117
 118     /**
 119      * Creates a <code>TestEnvironment</code> containing an instance of the
 120      * implementation object and related objects needed to perform test.
 121      *
 122      * @param tParam test parameters
 123      *
 124      * @return the created <code>TestEnvironment</code>
 125      *
 126      * @see #createTestEnvironment()
 127      * @see lib.TestEnvironment
 128      */
 129     public synchronized TestEnvironment getTestEnvironment( TestParameters tParam ) {
 130         TestEnvironment tEnv = null;
 131         try {
 132             tEnv = createTestEnvironment( tParam, log );
 133             System.out.println("Environment created");
 134             if (tEnv != null) {
 135                 tEnv.setTestCase(this);
 136             }
 137         } catch (Exception e) {
 138             String message = e.getMessage();
 139             if (message == null)
 140                 message = e.toString();
 141             System.out.println("Exception while getting Environment "+message);
 142             e.printStackTrace();
 143             cleanup(tParam, log);
 144         }
 145         return tEnv;
 146     }
 147
 148     /**
 149      * Disposes the <code>TestEnvironment</code> when it is not needed anymore.
 150      *
 151      * @param tEnv the environment to dispose
 152      * @param tParam test parameters
 153      */
 154     public synchronized void disposeTestEnvironment( TestEnvironment tEnv,
 155         TestParameters tParam ) {
 156         cleanup( tParam, log );
 157     }
 158
 159     /**
 160      * Called to create an instance of <code>TestEnvironment</code> with an
 161      * object to test and related objects. Subclasses should implement this
 162      * method to provide the implementation and related objects. The method is
 163      * called from <code>getTestEnvironment()</code>.
 164      *
 165      * @param tParam test parameters
 166      * @param log writer to log information while testing
 167      *
 168      * @see TestEnvironment
 169      * @see #getTestEnvironment()
 170      */
 171     protected abstract TestEnvironment createTestEnvironment(
 172             TestParameters tParam, PrintWriter log );
 173
 174     /**
 175      * @return the name of the object
 176      */
 177     public String getObjectName() {
 178         String clName = this.getClass().getName();
 179         return clName.substring( clName.lastIndexOf('.') + 1 );
 180     }
 181
 182 }