qadevOOo/runner/base/java_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: java_fat.java,v $
  10  * $Revision: 1.15.2.1 $
  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 com.sun.star.lang.XMultiServiceFactory;
  33
  34 import helper.APIDescGetter;
  35 import helper.AppProvider;
  36
  37 import java.io.BufferedReader;
  38 import java.io.FileReader;
  39 import java.io.PrintWriter;
  40
  41 import java.util.Vector;
  42
  43 import lib.MultiMethodTest;
  44 import lib.TestCase;
  45 import lib.TestEnvironment;
  46 import lib.TestParameters;
  47 import lib.TestResult;
  48
  49 import share.DescEntry;
  50 import share.DescGetter;
  51 import share.LogWriter;
  52
  53 import stats.OutProducerFactory;
  54 import stats.Summarizer;
  55
  56 import util.DynamicClassLoader;
  57
  58 /**
  59  *
  60  * this class handles tests written in java and running on a fat Office
  61  */
  62 public class java_fat implements TestBase
  63 {
  64
  65     private static boolean debug = false;
  66     private static boolean keepdocument = false;
  67     private static boolean logging = true;
  68     private static boolean newOffice = false;
  69     private DynamicClassLoader dcl = null;
  70
  71     private lib.TestParameters m_aParams;
  72     private AppProvider m_aOffice;
  73
  74     public boolean executeTest(lib.TestParameters param)
  75         {
  76             m_aParams = param;
  77
  78             dcl = new DynamicClassLoader();
  79
  80             DescGetter dg = new APIDescGetter();
  81             String job = (String) param.get("TestJob");
  82             String ExclusionFile = (String) param.get("ExclusionList");
  83             Vector exclusions = null;
  84             boolean retValue = true;
  85             debug = param.getBool("DebugIsActive");
  86             logging = param.getBool("LoggingIsActive");
  87             keepdocument = param.getBool("KeepDocument");
  88             newOffice = param.getBool(util.PropertyName.NEW_OFFICE_INSTANCE);
  89             if (keepdocument)
  90             {
  91                 System.setProperty("KeepDocument", "true");
  92             }
  93             if (ExclusionFile != null)
  94             {
  95                 exclusions = getExclusionList(ExclusionFile, debug);
  96             }
  97             //get Job-Descriptions
  98             System.out.println("Getting Descriptions for Job: " + job);
  99
 100             String sDescriptionPath = (String) param.get("DescriptionPath");
 101             DescEntry[] entries = dg.getDescriptionFor(job, sDescriptionPath, debug);
 102
 103             // System.out.println();
 104
 105             if (entries == null)
 106             {
 107                 System.out.println("Couldn't get Description for Job: " + job);
 108
 109                 return false;
 110             }
 111
 112 //        String officeProviderName = (String) param.get("OfficeProvider");
 113 //        AppProvider office = (AppProvider) dcl.getInstance(officeProviderName);
 114 //
 115 //        if (office == null) {
 116 //            System.out.println("ERROR: Wrong parameter 'OfficeProvider', " +
 117 //                               " it cannot be instantiated.");
 118 //            System.exit(-1);
 119 //        }
 120
 121             m_aOffice = startOffice(param);
 122
 123             boolean firstRun = true;
 124
 125             for (int l = 0; l < entries.length; l++)
 126             {
 127                 if (entries[l] == null)
 128                 {
 129                     continue;
 130                 }
 131
 132                 if (entries[l].hasErrorMsg)
 133                 {
 134                     System.out.println(entries[l].ErrorMsg);
 135                     retValue = false;
 136                     continue;
 137                 }
 138
 139                 if (!firstRun && newOffice)
 140                 {
 141                     if (!m_aOffice.closeExistingOffice(param, true))
 142                     {
 143                         m_aOffice.disposeManager(param);
 144                     }
 145                     startOffice(param);
 146                 }
 147                 firstRun = false;
 148
 149 //            XMultiServiceFactory msf = (XMultiServiceFactory) office.getManager(
 150 //                                               param);
 151
 152                 XMultiServiceFactory msf = (XMultiServiceFactory) param.getMSF();
 153
 154                 if (msf == null)
 155                 {
 156                     retValue = false;
 157
 158                     continue;
 159                 }
 160
 161 //            param.put("ServiceFactory", msf);
 162
 163                 DescEntry entry = entries[l];
 164
 165                 //get some helper classes
 166                 Summarizer sumIt = new Summarizer();
 167
 168                 TestCase tCase = null;
 169
 170                 try
 171                 {
 172                     tCase = (TestCase) dcl.getInstance("mod._" + entry.entryName);
 173                 }
 174                 catch (java.lang.IllegalArgumentException ie)
 175                 {
 176                     entry.ErrorMsg = ie.getMessage();
 177                     entry.hasErrorMsg = true;
 178                 }
 179                 catch (java.lang.NoClassDefFoundError ie)
 180                 {
 181                     entry.ErrorMsg = ie.getMessage();
 182                     entry.hasErrorMsg = true;
 183                 }
 184
 185                 if (tCase == null)
 186                 {
 187                     Summarizer.summarizeDown(entry, entry.ErrorMsg);
 188
 189                     LogWriter sumObj = OutProducerFactory.createOutProducer(param);
 190                     entry.UserDefinedParams = param;
 191                     sumObj.initialize(entry, logging);
 192                     sumObj.summary(entry);
 193
 194                     continue;
 195                 }
 196
 197                 if (debug)
 198                 {
 199                     System.out.println("sleeping 5 seconds..");
 200                 }
 201                 util.utils.shortWait(5000);
 202
 203                 System.out.println("Creating: " + entry.entryName);
 204
 205                 LogWriter log = (LogWriter) dcl.getInstance((String) param.get("LogWriter"));
 206                 log.initialize(entry, logging);
 207                 entry.UserDefinedParams = param;
 208
 209                 TestEnvironment tEnv = null;
 210
 211                 try
 212                 {
 213                     tCase.setLogWriter((PrintWriter) log);
 214                     tCase.initializeTestCase(param);
 215                     tEnv = tCase.getTestEnvironment(param);
 216                 }
 217                 catch (Exception e)
 218                 {
 219                     System.out.println("Exception while creating " + tCase.getObjectName());
 220                     System.out.println("Message " + e.getMessage());
 221                     e.printStackTrace();
 222                     tEnv = null;
 223                 }
 224                 catch (java.lang.UnsatisfiedLinkError e)
 225                 {
 226                     System.out.println("Exception while creating " + tCase.getObjectName());
 227                     System.out.println("Message " + e.getMessage());
 228                     tEnv = null;
 229                 }
 230                 catch (java.lang.NoClassDefFoundError e)
 231                 {
 232                     System.out.println("Exception while creating " + tCase.getObjectName());
 233                     System.out.println("Message " + e.getMessage());
 234                     tEnv = null;
 235                 }
 236
 237                 if (tEnv == null)
 238                 {
 239                     Summarizer.summarizeDown(entry, "Couldn't create " + tCase.getObjectName());
 240
 241                     LogWriter sumObj = OutProducerFactory.createOutProducer(param);
 242                     entry.UserDefinedParams = param;
 243                     sumObj.initialize(entry, logging);
 244                     sumObj.summary(entry);
 245
 246                     continue;
 247                 }
 248
 249                 System.out.println(tCase.getObjectName() + " recreated ");
 250
 251                 for (int j = 0; j < entry.SubEntryCount; j++)
 252                 {
 253                     DescEntry aSubEntry = entry.SubEntries[j];
 254                     if (!aSubEntry.isToTest)
 255                     {
 256                         Summarizer.summarizeDown(aSubEntry, "not part of the job");
 257
 258                         continue;
 259                     }
 260
 261                     if ((exclusions != null) && (exclusions.contains(aSubEntry.longName)))
 262                     {
 263                         Summarizer.summarizeDown(aSubEntry, "known issue");
 264
 265                         continue;
 266                     }
 267
 268                     System.out.println("running: '" + aSubEntry.entryName + "'");
 269
 270                     LogWriter ifclog = (LogWriter) dcl.getInstance( (String) param.get("LogWriter"));
 271
 272                     ifclog.initialize(aSubEntry, logging);
 273                     aSubEntry.UserDefinedParams = param;
 274                     aSubEntry.Logger = ifclog;
 275
 276                     if ((tEnv == null) || tEnv.isDisposed())
 277                     {
 278                         closeExistingOffice();
 279                         tEnv = getEnv(entry, param);
 280                     }
 281
 282                     // MultiMethodTest ifc = null;
 283                     lib.TestResult res = null;
 284
 285                     // run the interface test twice if it failed.
 286                     int countInterfaceTestRun = 0;
 287                     boolean finished = false;
 288                     while (!finished)
 289                     {
 290                         try
 291                         {
 292                             countInterfaceTestRun++;
 293                             finished = true;
 294                             res = executeInterfaceTest(aSubEntry, tEnv, param);
 295                         }
 296                         catch (IllegalArgumentException iae)
 297                         {
 298                             System.out.println("Couldn't load class " + aSubEntry.entryName);
 299                             System.out.println("**** " + iae.getMessage() + " ****");
 300                             Summarizer.summarizeDown(aSubEntry, iae.getMessage());
 301                         }
 302                         catch (java.lang.NoClassDefFoundError iae)
 303                         {
 304                             System.out.println("Couldn't load class " + aSubEntry.entryName);
 305                             System.out.println("**** " + iae.getMessage() + " ****");
 306                             Summarizer.summarizeDown(aSubEntry, iae.getMessage());
 307                         }
 308                         catch (java.lang.RuntimeException e)
 309                         {
 310                             closeExistingOffice();
 311                             tEnv = getEnv(entry, param);
 312                             if (countInterfaceTestRun < 2)
 313                             {
 314                                 finished = false;
 315                             }
 316                             else
 317                             {
 318                                 Summarizer.summarizeDown(aSubEntry, e.toString() + ".FAILED");
 319                             }
 320                         }
 321                     }
 322                     setState(aSubEntry, res);
 323
 324                     sumIt.summarizeUp(aSubEntry);
 325
 326                     LogWriter sumIfc = OutProducerFactory.createOutProducer(param);
 327                     aSubEntry.UserDefinedParams = param;
 328                     sumIfc.initialize(aSubEntry, logging);
 329                     sumIfc.summary(aSubEntry);
 330                 }
 331
 332                 try
 333                 {
 334                     if (!keepdocument)
 335                     {
 336                         tCase.cleanupTestCase(param);
 337                     }
 338                 }
 339                 catch (Exception e)
 340                 {
 341                     System.out.println("couldn't cleanup");
 342                 }
 343                 catch (java.lang.NoClassDefFoundError e)
 344                 {
 345                     System.out.println("couldn't cleanup");
 346                 }
 347
 348                 sumIt.summarizeUp(entry);
 349
 350                 LogWriter sumObj = OutProducerFactory.createOutProducer(param);
 351
 352                 sumObj.initialize(entry, logging);
 353                 sumObj.summary(entry);
 354             }
 355
 356             if (entries.length > 0)
 357             {
 358                 System.out.println();
 359
 360                 int counter = 0;
 361                 System.out.println("Failures that appeared during scenario execution:");
 362
 363                 for (int i = 0; i < entries.length; i++)
 364                 {
 365                     if (!entries[i].State.endsWith("OK"))
 366                     {
 367                         System.out.println("\t " + entries[i].longName);
 368                         counter++;
 369                     }
 370                 }
 371
 372                 System.out.println(counter + " of " + entries.length + " tests failed");
 373             }
 374
 375             closeExistingOffice();
 376             return retValue;
 377         }
 378
 379     private void setState(DescEntry aSubEntry, lib.TestResult res)
 380     {
 381         if (res != null)
 382         {
 383             for (int k = 0; k < aSubEntry.SubEntryCount; k++)
 384             {
 385                 DescEntry aSubSubEntry = aSubEntry.SubEntries[k];
 386                 if (res.hasMethod( aSubSubEntry.entryName))
 387                 {
 388                     aSubSubEntry.State = res.getStatusFor(aSubSubEntry.entryName).toString();
 389                 }
 390             }
 391         }
 392     }
 393
 394     private TestEnvironment getEnv(DescEntry entry, TestParameters param)
 395         {
 396 //        if (dcl == null)
 397 //            dcl = new DynamicClassLoader();
 398 //        String officeProviderName = (String) param.get("OfficeProvider");
 399 //        AppProvider office = (AppProvider) dcl.getInstance(officeProviderName);
 400 //
 401 //        if (office == null) {
 402 //            System.out.println("ERROR: Wrong parameter 'OfficeProvider', " +
 403 //                               " it cannot be instantiated.");
 404 //            System.exit(-1);
 405 //        }
 406 //
 407 //        XMultiServiceFactory msf = (XMultiServiceFactory) office.getManager(
 408 //                                           param);
 409 //
 410 //        if (msf == null) {
 411 //            return null;
 412 //        }
 413 //
 414 //        param.put("ServiceFactory", msf);
 415
 416             // AppProvider office = startOffice(param);
 417
 418             TestCase tCase = null;
 419
 420             try
 421             {
 422                 tCase = (TestCase) dcl.getInstance("mod._" + entry.entryName);
 423             }
 424             catch (java.lang.IllegalArgumentException ie)
 425             {
 426                 entry.ErrorMsg = ie.getMessage();
 427                 entry.hasErrorMsg = true;
 428             }
 429             catch (java.lang.NoClassDefFoundError ie)
 430             {
 431                 entry.ErrorMsg = ie.getMessage();
 432                 entry.hasErrorMsg = true;
 433             }
 434
 435             System.out.println("Creating: " + entry.entryName);
 436
 437             entry.UserDefinedParams = param;
 438
 439             LogWriter log = (LogWriter) dcl.getInstance((String) param.get("LogWriter"));
 440             log.initialize(entry, logging);
 441             tCase.setLogWriter((PrintWriter) log);
 442
 443             TestEnvironment tEnv = null;
 444
 445             try
 446             {
 447                 tCase.initializeTestCase(param);
 448                 tEnv = tCase.getTestEnvironment(param);
 449             }
 450             catch (com.sun.star.lang.DisposedException de)
 451             {
 452                 System.out.println("Office disposed");
 453                 closeExistingOffice();
 454             }
 455             catch (lib.StatusException e)
 456             {
 457                 System.out.println(e.getMessage());
 458
 459                 closeExistingOffice();
 460
 461                 entry.ErrorMsg = e.getMessage();
 462                 entry.hasErrorMsg = true;
 463             }
 464
 465             return tEnv;
 466         }
 467
 468     private void closeExistingOffice()
 469         {
 470             helper.ProcessHandler ph = (helper.ProcessHandler) m_aParams.get("AppProvider");
 471
 472             if (ph != null)
 473             {
 474                 m_aOffice.closeExistingOffice(m_aParams, true);
 475                 shortWait(5000);
 476             }
 477
 478         }
 479
 480     private void shortWait(int millis)
 481         {
 482             try
 483             {
 484                 Thread.sleep(millis);
 485             }
 486             catch (java.lang.InterruptedException ie)
 487             {
 488             }
 489         }
 490
 491     private Vector getExclusionList(String url, boolean debug)
 492         {
 493             Vector entryList = new Vector();
 494             String line = "#";
 495             BufferedReader exclusion = null;
 496
 497             try
 498             {
 499                 exclusion = new BufferedReader(new FileReader(url));
 500             }
 501             catch (java.io.FileNotFoundException fnfe)
 502             {
 503                 if (debug)
 504                 {
 505                     System.out.println("Couldn't find file " + url);
 506                 }
 507
 508                 return entryList;
 509             }
 510
 511             while (line != null)
 512             {
 513                 try
 514                 {
 515                     if (!line.startsWith("#") && (line.length() > 1))
 516                     {
 517                         entryList.add(line.trim());
 518                     }
 519
 520                     line = exclusion.readLine();
 521                 }
 522                 catch (java.io.IOException ioe)
 523                 {
 524                     if (debug)
 525                     {
 526                         System.out.println("Exception while reading exclusion list");
 527                     }
 528
 529                     return entryList;
 530                 }
 531             }
 532
 533             try
 534             {
 535                 exclusion.close();
 536             }
 537             catch (java.io.IOException ioe)
 538             {
 539                 if (debug)
 540                 {
 541                     System.out.println("Couldn't close file " + url);
 542                 }
 543
 544                 return entryList;
 545             }
 546
 547             return entryList;
 548         }
 549
 550     private TestResult executeInterfaceTest(
 551         DescEntry entry, TestEnvironment tEnv, TestParameters param)
 552         throws IllegalArgumentException, java.lang.NoClassDefFoundError
 553         {
 554             MultiMethodTest ifc = (MultiMethodTest) dcl.getInstance(entry.entryName);
 555             return ifc.run(entry, tEnv, param);
 556         }
 557
 558     private AppProvider startOffice(lib.TestParameters param)
 559         {
 560
 561             if (dcl == null)
 562             {
 563                 dcl = new DynamicClassLoader();
 564             }
 565
 566             String officeProviderName = (String) param.get("OfficeProvider");
 567             AppProvider office = (AppProvider) dcl.getInstance(officeProviderName);
 568
 569             if (office == null)
 570             {
 571                 System.out.println("ERROR: Wrong parameter 'OfficeProvider', " + " it cannot be instantiated.");
 572                 System.exit(-1);
 573             }
 574
 575             XMultiServiceFactory msf = (XMultiServiceFactory) office.getManager(param);
 576
 577             if (msf != null)
 578             {
 579                 param.put("ServiceFactory", msf);
 580             }
 581
 582             return office;
 583         }
 584 }