qadevOOo/runner/base/basic_fat.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: basic_fat.java,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 package base;
  31
  32 import base.TestBase;
  33
  34 import basicrunner.BasicIfcTest;
  35 import basicrunner.BasicTestCase;
  36
  37 import com.sun.star.lang.XMultiServiceFactory;
  38
  39 import helper.APIDescGetter;
  40 import helper.AppProvider;
  41 import helper.OfficeProvider;
  42 import helper.OfficeWatcher;
  43
  44 import java.io.BufferedReader;
  45 import java.io.FileReader;
  46 import java.io.PrintWriter;
  47
  48 import java.util.Vector;
  49
  50 import lib.TestCase;
  51 import lib.TestEnvironment;
  52 import lib.TestParameters;
  53
  54 import share.DescEntry;
  55 import share.DescGetter;
  56 import share.LogWriter;
  57
  58 import stats.OutProducerFactory;
  59 import stats.Summarizer;
  60
  61 import util.DynamicClassLoader;
  62
  63 /**
  64  * The testbase for executing basic tests.
  65  *  @see lib.TestBase
  66  */
  67 public class basic_fat implements TestBase
  68 {
  69
  70     public static boolean debug = false;
  71
  72     /**
  73      *  Execute a test.
  74      *  @param param The test parameters.
  75      *  @param return True, if the test was executed.
  76      */
  77     public boolean executeTest(TestParameters param)
  78     {
  79         DescGetter dg = new APIDescGetter();
  80         String job = (String) param.get("TestJob");
  81         OfficeProvider office = null;
  82         debug = param.getBool("DebugIsActive");
  83
  84
  85         //get Job-Descriptions
  86         System.out.print("Getting Descriptions for Job: " + job + " from ");
  87
  88         DescEntry[] entries = dg.getDescriptionFor(job,
  89                 (String) param.get(
  90                 "DescriptionPath"),
  91                 debug);
  92
  93         if (entries == null)
  94         {
  95             System.out.println("Couldn't get Description for Job");
  96
  97             return false;
  98         }
  99
 100         String ExclusionFile = (String) param.get("ExclusionList");
 101         Vector exclusions = null;
 102
 103         if (ExclusionFile != null)
 104         {
 105             exclusions = getExclusionList(ExclusionFile, debug);
 106         }
 107
 108         String conStr = (String) param.get("ConnectionString");
 109         System.out.println("");
 110         System.out.print("> Connecting the Office ");
 111         System.out.println("With " + conStr);
 112
 113         for (int l = 0; l < entries.length; l++)
 114         {
 115             if (entries[l].hasErrorMsg)
 116             {
 117                 System.out.println(entries[l].ErrorMsg);
 118
 119                 continue;
 120             }
 121
 122             office = new OfficeProvider();
 123
 124             XMultiServiceFactory msf = (XMultiServiceFactory) office.getManager(
 125                     param);
 126
 127             if (msf == null)
 128             {
 129                 return false;
 130             }
 131
 132             param.put("ServiceFactory", msf);
 133
 134             DescEntry entry = entries[l];
 135
 136             //get some helper classes
 137             Summarizer sumIt = new Summarizer();
 138             DynamicClassLoader dcl = new DynamicClassLoader();
 139
 140             TestCase tCase = null;
 141
 142             tCase = (TestCase) new BasicTestCase(entry);
 143
 144             if (tCase == null)
 145             {
 146                 sumIt.summarizeDown(entry, entry.ErrorMsg);
 147
 148                 LogWriter sumObj = OutProducerFactory.createOutProducer(param);
 149                 sumObj.initialize(entry, true);
 150                 sumObj.summary(entry);
 151
 152                 continue;
 153             }
 154
 155             System.out.println("Creating: " + tCase.getObjectName());
 156
 157             LogWriter log = (LogWriter) dcl.getInstance(
 158                     (String) param.get("LogWriter"));
 159             log.initialize(entry, true);
 160             entry.UserDefinedParams = param;
 161             tCase.setLogWriter((PrintWriter) log);
 162
 163             try
 164             {
 165                 tCase.initializeTestCase(param);
 166             }
 167             catch (RuntimeException e)
 168             {
 169                 helper.ProcessHandler ph = (helper.ProcessHandler) param.get(
 170                         "AppProvider");
 171
 172                 if (ph != null)
 173                 {
 174                     OfficeWatcher ow = (OfficeWatcher) param.get("Watcher");
 175
 176                     if ((ow != null) && ow.isAlive())
 177                     {
 178                         ow.finish = true;
 179                     }
 180
 181                     ph.kill();
 182                     shortWait(5000);
 183                 }
 184
 185                 continue;
 186             }
 187
 188             TestEnvironment tEnv = tCase.getTestEnvironment(param);
 189
 190             if (tEnv == null)
 191             {
 192                 sumIt.summarizeDown(entry, "Unable to create testcase");
 193
 194                 LogWriter sumObj = OutProducerFactory.createOutProducer(param);
 195                 sumObj.initialize(entry, true);
 196                 sumObj.summary(entry);
 197
 198                 helper.ProcessHandler ph = (helper.ProcessHandler) param.get(
 199                         "AppProvider");
 200
 201                 if (ph != null)
 202                 {
 203                     OfficeWatcher ow = (OfficeWatcher) param.get("Watcher");
 204
 205                     if ((ow != null) && ow.isAlive())
 206                     {
 207                         ow.finish = true;
 208                     }
 209
 210                     ph.kill();
 211                     shortWait(5000);
 212                 }
 213
 214                 continue;
 215             }
 216
 217             System.out.println("created " + tCase.getObjectName());
 218
 219             for (int j = 0; j < entry.SubEntryCount; j++)
 220             {
 221                 if (!entry.SubEntries[j].isToTest)
 222                 {
 223                     Summarizer.summarizeDown(entry.SubEntries[j],
 224                             "not part of the job");
 225
 226                     continue;
 227                 }
 228
 229                 if ((exclusions != null) &&
 230                         (exclusions.contains(entry.SubEntries[j].longName)))
 231                 {
 232                     Summarizer.summarizeDown(entry.SubEntries[j],
 233                             "known issue");
 234
 235                     continue;
 236                 }
 237
 238                 System.out.println("running: " +
 239                         entry.SubEntries[j].entryName);
 240
 241                 LogWriter ifclog = (LogWriter) dcl.getInstance(
 242                         (String) param.get("LogWriter"));
 243                 ifclog.initialize(entry.SubEntries[j], true);
 244                 entry.SubEntries[j].UserDefinedParams = param;
 245                 entry.SubEntries[j].Logger = ifclog;
 246
 247                 if ((tEnv == null) || tEnv.isDisposed())
 248                 {
 249                     helper.ProcessHandler ph = (helper.ProcessHandler) param.get(
 250                             "AppProvider");
 251
 252                     if (ph != null)
 253                     {
 254                         office.closeExistingOffice(param, true);
 255                         shortWait(5000);
 256                     }
 257
 258                     tEnv = getEnv(entry, param);
 259                 }
 260
 261                 BasicIfcTest ifc = null;
 262                 lib.TestResult res = null;
 263                 ifc = new BasicIfcTest(entry.SubEntries[j].longName);
 264                 res = ifc.run(entry.SubEntries[j], tEnv, param);
 265
 266                 sumIt.summarizeUp(entry.SubEntries[j]);
 267
 268                 LogWriter sumIfc = OutProducerFactory.createOutProducer(param);
 269
 270                 sumIfc.initialize(entry.SubEntries[j], true);
 271                 sumIfc.summary(entry.SubEntries[j]);
 272             }
 273
 274             try
 275             {
 276                 tCase.cleanupTestCase(param);
 277             }
 278             catch (Exception e)
 279             {
 280                 log.println("TestCase already gone");
 281
 282                 helper.ProcessHandler ph = (helper.ProcessHandler) param.get(
 283                         "AppProvider");
 284
 285                 if (ph != null)
 286                 {
 287                     office.closeExistingOffice(param, true);
 288                     shortWait(5000);
 289                 }
 290             }
 291
 292             sumIt.summarizeUp(entry);
 293
 294             LogWriter sumObj = OutProducerFactory.createOutProducer(param);
 295             sumObj.initialize(entry, true);
 296             sumObj.summary(entry);
 297         }
 298
 299         if (entries.length > 1)
 300         {
 301             System.out.println();
 302
 303             int counter = 0;
 304             System.out.println(
 305                     "Failures that appeared during scenario execution:");
 306
 307             for (int i = 0; i < entries.length; i++)
 308             {
 309                 if (!entries[i].State.endsWith("OK"))
 310                 {
 311                     System.out.println("\t " + entries[i].longName);
 312                     counter++;
 313                 }
 314             }
 315
 316             System.out.println(counter + " of " + entries.length +
 317                     " tests failed");
 318         }
 319
 320         helper.ProcessHandler ph = (helper.ProcessHandler) param.get(
 321                 "AppProvider");
 322
 323         if (ph != null)
 324         {
 325             office.closeExistingOffice(param, true);
 326         }
 327
 328         return true;
 329     }
 330
 331     protected TestEnvironment getEnv(DescEntry entry, TestParameters param)
 332     {
 333         DynamicClassLoader dcl = new DynamicClassLoader();
 334         String officeProviderName = (String) param.get("OfficeProvider");
 335         AppProvider office = (AppProvider) dcl.getInstance(officeProviderName);
 336
 337         if (office == null)
 338         {
 339             System.out.println("ERROR: Wrong parameter 'OfficeProvider', " +
 340                     " it cannot be instantiated.");
 341             System.exit(-1);
 342         }
 343
 344         XMultiServiceFactory msf = (XMultiServiceFactory) office.getManager(
 345                 param);
 346
 347         if (msf == null)
 348         {
 349             return null;
 350         }
 351
 352         param.put("ServiceFactory", msf);
 353
 354         TestCase tCase = (TestCase) new BasicTestCase(entry);
 355
 356         System.out.println("Creating: " + tCase.getObjectName());
 357
 358         LogWriter log = (LogWriter) dcl.getInstance(
 359                 (String) param.get("LogWriter"));
 360         log.initialize(entry, true);
 361         entry.UserDefinedParams = param;
 362         tCase.setLogWriter((PrintWriter) log);
 363
 364         TestEnvironment tEnv = null;
 365
 366         try
 367         {
 368             tCase.initializeTestCase(param);
 369             tEnv = tCase.getTestEnvironment(param);
 370         }
 371         catch (java.lang.RuntimeException e)
 372         {
 373             System.out.println(e.getMessage());
 374
 375             helper.ProcessHandler ph = (helper.ProcessHandler) param.get(
 376                     "AppProvider");
 377
 378             if (ph != null)
 379             {
 380                 office.closeExistingOffice(param, true);
 381                 shortWait(5000);
 382             }
 383
 384             entry.ErrorMsg = e.getMessage();
 385             entry.hasErrorMsg = true;
 386         }
 387
 388         return tEnv;
 389     }
 390
 391     protected void shortWait(int millis)
 392     {
 393         try
 394         {
 395             Thread.sleep(millis);
 396         }
 397         catch (java.lang.InterruptedException ie)
 398         {
 399         }
 400     }
 401
 402     protected Vector getExclusionList(String url, boolean debug)
 403     {
 404         Vector entryList = new Vector();
 405         String line = "#";
 406         BufferedReader exclusion = null;
 407
 408         try
 409         {
 410             exclusion = new BufferedReader(new FileReader(url));
 411         }
 412         catch (java.io.FileNotFoundException fnfe)
 413         {
 414             if (debug)
 415             {
 416                 System.out.println("Couldn't find file " + url);
 417             }
 418
 419             return entryList;
 420         }
 421
 422         while (line != null)
 423         {
 424             try
 425             {
 426                 if (!line.startsWith("#"))
 427                 {
 428                     entryList.add(line);
 429                 }
 430
 431                 line = exclusion.readLine();
 432             }
 433             catch (java.io.IOException ioe)
 434             {
 435                 if (debug)
 436                 {
 437                     System.out.println(
 438                             "Exception while reading exclusion list");
 439                 }
 440
 441                 return entryList;
 442             }
 443         }
 444
 445         try
 446         {
 447             exclusion.close();
 448         }
 449         catch (java.io.IOException ioe)
 450         {
 451             if (debug)
 452             {
 453                 System.out.println("Couldn't close file " + url);
 454             }
 455
 456             return entryList;
 457         }
 458
 459         return entryList;
 460     }
 461 }