qadevOOo/runner/helper/APIDescGetter.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 helper;
  19
  20 import java.io.BufferedReader;
  21 import java.io.File;
  22 import java.io.FileReader;
  23 import java.io.InputStream;
  24 import java.io.InputStreamReader;
  25 import java.util.ArrayList;
  26 import java.util.Collections;
  27 import java.util.StringTokenizer;
  28 import java.util.jar.JarEntry;
  29
  30 import share.DescEntry;
  31 import share.DescGetter;
  32
  33 /**
  34  * This is the Office-API specific DescGetter<br>
  35  * <br>
  36  * Examples:<br><br>
  37  * -o sw.SwXBodyText<br>
  38  * runs the module test of <B>Sw.SwXBodyText</B><br>
  39  * <br>
  40  * -o sw.SwXBodyText::com::sun::star::text::Text<br>
  41  * runs only the interface test <B>com.sun.star.textText</B> of the module <B>Sw.SwXBodyText</B><br>
  42  * <br>
  43  * -o sw.SwXBodyText::com::sun::star::text::Text,com::sun::star::text::XSimpleText<br>
  44  * runs only the interfaces test <B>com.sun.star.textText</B> and <B>com.sun.star.text.XSimpleText</B> of the module <B>Sw.SwXBodyText</B><br>
  45  * <br>
  46  * -p sw<br>
  47  * runs all modules of the project <B>sw</B><br>
  48  * <br>
  49  * -p listall<br>
  50  * lists all known module tests<br>
  51  * <br>
  52  * -sce SCENARIO_FILE<br>
  53  * A scenario file is a property file which could cotain <B>-o</B> and <B>-p</B> properties<br>
  54  * <br>
  55  * -sce sw.SwXBodyText,sw.SwXBookmark<br>
  56  * runs the module test of <B>Sw.SwXBodyText</B> and <B>sw.SwXBookmark</B><br>
  57  */
  58 public class APIDescGetter extends DescGetter
  59 {
  60
  61     private static String fullJob = null;
  62
  63     /*
  64      * gets the needed information about a StarOffice component
  65      * @param descPath Path to the ComponentDescription
  66      * @param entry contains the entry name, e.g. sw.SwXBodyText
  67      * @param debug if true some debug information is displayed on standard out
  68      */
  69     public DescEntry[] getDescriptionFor(String job, String descPath,
  70             boolean debug)
  71     {
  72
  73         if (job.startsWith("-o"))
  74         {
  75             job = job.substring(3, job.length()).trim();
  76
  77             if (job.indexOf(".") < 0)
  78             {
  79                 return null;
  80             }
  81
  82             // special in case several Interfaces are given comma separated
  83             if (job.indexOf(",") < 0)
  84             {
  85                 DescEntry entry = getDescriptionForSingleJob(job, descPath,
  86                         debug);
  87
  88                 if (entry != null)
  89                 {
  90                     return new DescEntry[]
  91                             {
  92                                 entry
  93                             };
  94                 }
  95                 else
  96                 {
  97                     return null;
  98                 }
  99             }
 100             else
 101             {
 102                 ArrayList<String> subs = getSubInterfaces(job);
 103                 String partjob = job.substring(0, job.indexOf(",")).trim();
 104                 DescEntry entry = getDescriptionForSingleJob(partjob, descPath,
 105                         debug);
 106
 107                 if (entry != null)
 108                 {
 109                     for (int i = 0; i < entry.SubEntryCount; i++)
 110                     {
 111                         String subEntry = entry.SubEntries[i].longName;
 112                         int cpLength = entry.longName.length();
 113                         subEntry = subEntry.substring(cpLength + 2,
 114                                 subEntry.length());
 115
 116                         if (subs.contains(subEntry))
 117                         {
 118                             entry.SubEntries[i].isToTest = true;
 119                         }
 120                     }
 121
 122                     return new DescEntry[]
 123                             {
 124                                 entry
 125                             };
 126                 }
 127                 else
 128                 {
 129                     return null;
 130                 }
 131             }
 132         }
 133
 134         if (job.startsWith("-p"))
 135         {
 136             job = job.substring(3, job.length()).trim();
 137
 138             String[] scenario = createScenario(descPath, job, debug);
 139             if (scenario == null)
 140             {
 141                 return null;
 142             }
 143             DescEntry[] entries = new DescEntry[scenario.length];
 144             for (int i = 0; i < scenario.length; i++)
 145             {
 146                 entries[i] = getDescriptionForSingleJob(
 147                         scenario[i].substring(3).trim(), descPath, debug);
 148             }
 149             if (job.equals("listall"))
 150             {
 151                 util.dbg.printArray(scenario);
 152                 System.exit(0);
 153             }
 154             return entries;
 155         }
 156
 157         if (job.startsWith("-sce"))
 158         {
 159             job = job.substring(5, job.length()).trim();
 160
 161             File sceFile = new File(job);
 162             if (sceFile.exists())
 163             {
 164                 return getScenario(job, descPath, debug);
 165             }
 166             else
 167             {
 168                 //look the scenarion like this? :
 169                 // sw.SwXBodyText,sw.SwXTextCursor
 170                 ArrayList<String> subs = getSubObjects(job);
 171                 DescEntry[] entries = new DescEntry[subs.size()];
 172
 173                 for (int i = 0; i < subs.size(); i++)
 174                 {
 175                     entries[i] = getDescriptionForSingleJob(
 176                             subs.get(i), descPath, debug);
 177                 }
 178                 return entries;
 179             }
 180         }
 181         else
 182         {
 183             return null;
 184         }
 185     }
 186
 187     protected DescEntry getDescriptionForSingleJob(String job, String descPath,
 188             boolean debug)
 189     {
 190         boolean isSingleInterface = job.indexOf("::") > 0;
 191         fullJob = job;
 192
 193         if (isSingleInterface)
 194         {
 195             job = job.substring(0, job.indexOf("::"));
 196         }
 197
 198         if (job.startsWith("bugs"))
 199         {
 200             DescEntry Entry = new DescEntry();
 201             Entry.entryName = job;
 202             Entry.longName = job;
 203             Entry.EntryType = "bugdoc";
 204             Entry.isOptional = false;
 205             Entry.isToTest = true;
 206             Entry.SubEntryCount = 0;
 207             Entry.hasErrorMsg = false;
 208             Entry.State = "non possible";
 209
 210             return Entry;
 211         }
 212
 213         DescEntry entry = null;
 214
 215         if (descPath != null)
 216         {
 217             if (debug)
 218             {
 219                 System.out.println("## reading from File " + descPath);
 220             }
 221
 222             entry = getFromDirectory(descPath, job, debug);
 223         }
 224         else
 225         {
 226             if (debug)
 227             {
 228                 System.out.println("## reading from jar");
 229             }
 230
 231             entry = getFromClassPath(job, debug);
 232         }
 233
 234         boolean foundInterface = false;
 235
 236         if (isSingleInterface && (entry != null))
 237         {
 238             for (int i = 0; i < entry.SubEntryCount; i++)
 239             {
 240                 if (!(entry.SubEntries[i].longName).equals(fullJob))
 241                 {
 242                     entry.SubEntries[i].isToTest = false;
 243                 }
 244                 else
 245                 {
 246                     foundInterface = true;
 247                     entry.SubEntries[i].isToTest = true;
 248                 }
 249             }
 250         }
 251
 252         if (isSingleInterface && !foundInterface || entry == null)
 253         {
 254             return setErrorDescription(entry,
 255                     "couldn't find a description for test '" + fullJob + "'");
 256         }
 257
 258         return entry;
 259     }
 260
 261     protected static DescEntry[] getSubEntries(BufferedReader cvsFile,
 262             DescEntry parent, boolean debug)
 263     {
 264         String line = "";
 265         String old_ifc_name = "";
 266         ArrayList<DescEntry> ifc_names = new ArrayList<DescEntry>();
 267         ArrayList<DescEntry> meth_names = new ArrayList<DescEntry>();
 268         DescEntry ifcDesc = null;
 269
 270         while (line != null)
 271         {
 272             try
 273             {
 274                 line = cvsFile.readLine();
 275                 if (line == null)
 276                 {
 277                     continue;
 278                 }
 279                 if (line.startsWith("#"))
 280                 {
 281                     continue;
 282                 }
 283                 if (line.length() <= 0)
 284                 {
 285                     continue;
 286                 }
 287 // TODO Probleme here
 288                 // int nFirstSemicolon = line.indexOf(";");
 289                 // int nLastSemicolon = line.lastIndexOf(";");
 290
 291                 String ifc_name = ""; //  = line.substring(line.indexOf(";") + 2, line.lastIndexOf(";") - 1);
 292                 String meth_name = ""; //  = line.substring(line.lastIndexOf(";") + 2, line.length() - 1);
 293                 StringTokenizer aToken = new StringTokenizer(line, ";");
 294                 if (aToken.countTokens() < 3)
 295                 {
 296                     System.out.println("Wrong format: Line '" + line + "' is not supported.");
 297                     continue;
 298                 }
 299                 if (aToken.hasMoreTokens())
 300                 {
 301                     StringHelper.removeQuoteIfExists(aToken.nextToken());
 302                 }
 303                 if (aToken.hasMoreTokens())
 304                 {
 305                     ifc_name = StringHelper.removeQuoteIfExists(aToken.nextToken());
 306                 }
 307                 if (aToken.hasMoreTokens())
 308                 {
 309                     meth_name = StringHelper.removeQuoteIfExists(aToken.nextToken());
 310                 }
 311
 312                 // String ifc_name = line.substring(line.indexOf(";") + 2, line.lastIndexOf(";") - 1);
 313                 // String meth_name = line.substring(line.lastIndexOf(";") + 2, line.length() - 1);
 314
 315                 DescEntry methDesc = createDescEntry(meth_name, ifc_name, parent);
 316
 317                 if (!ifc_name.equals(old_ifc_name))
 318                 {
 319                     if (ifcDesc != null)
 320                     {
 321                         ifcDesc.SubEntries = getDescArray(meth_names.toArray());
 322                         ifcDesc.SubEntryCount = meth_names.size();
 323
 324                         //mark service/interface as optional if all methods/properties are optional
 325                         boolean allOptional = true;
 326
 327                         for (int k = 0; k < ifcDesc.SubEntryCount; k++)
 328                         {
 329                             if (!ifcDesc.SubEntries[k].isOptional)
 330                             {
 331                                 allOptional = false;
 332                             }
 333                         }
 334
 335                         if (!ifcDesc.isOptional && allOptional)
 336                         {
 337                             ifcDesc.isOptional = allOptional;
 338                         }
 339
 340                         meth_names.clear();
 341                         ifc_names.add(ifcDesc);
 342                     }
 343
 344                     ifcDesc = new DescEntry();
 345                     ifcDesc.isToTest = true;
 346                     old_ifc_name = ifc_name;
 347
 348                     if (ifc_name.indexOf("#optional") > 0)
 349                     {
 350                         ifcDesc.isOptional = true;
 351                         ifc_name = ifc_name.substring(0, ifc_name.indexOf("#"));
 352                     }
 353
 354                     String className = createClassName(ifc_name);
 355
 356                     ifcDesc.EntryType = entryType;
 357                     ifcDesc.entryName = "ifc" + className;
 358                     ifcDesc.longName = parent.entryName + "::" + ifc_name;
 359                 }
 360                 meth_names.add(methDesc);
 361
 362             }
 363             catch (java.io.IOException ioe)
 364             {
 365                 parent.hasErrorMsg = true;
 366                 parent.ErrorMsg = "IOException while reading the description";
 367
 368                 return null;
 369             }
 370         }
 371
 372         ifcDesc.SubEntries = getDescArray(meth_names.toArray());
 373         ifcDesc.SubEntryCount = meth_names.size();
 374
 375         //mark service/interface as optional if all methods/properties are optional
 376         boolean allOptional = true;
 377
 378         for (int k = 0; k < ifcDesc.SubEntryCount; k++)
 379         {
 380             if (!ifcDesc.SubEntries[k].isOptional)
 381             {
 382                 allOptional = false;
 383             }
 384         }
 385
 386         if (!ifcDesc.isOptional && allOptional)
 387         {
 388             ifcDesc.isOptional = allOptional;
 389         }
 390
 391         ifc_names.add(ifcDesc);
 392
 393         return getDescArray(makeArray(ifc_names));
 394     }
 395     private static String createClassName(String _ifc_name)
 396     {
 397         StringTokenizer st = new StringTokenizer(_ifc_name, ":");
 398         String className = "";
 399
 400         int count = 3;
 401
 402         if (_ifc_name.startsWith("drafts"))
 403         {
 404             count = 4;
 405         }
 406
 407         for (int i = 0; st.hasMoreTokens(); i++)
 408         {
 409             String token = st.nextToken();
 410
 411             // skipping (drafts.)com.sun.star
 412             if (i >= count)
 413             {
 414                 if (!st.hasMoreTokens())
 415                 {
 416                     // inserting '_' before the last token
 417                     token = "_" + token;
 418                 }
 419
 420                 className += ("." + token);
 421             }
 422         }
 423         return className;
 424     }
 425
 426     private static String entryType;
 427
 428     private static DescEntry createDescEntry(String meth_name, String ifc_name, DescEntry parent)
 429     {
 430         entryType = "service";
 431         DescEntry methDesc = new DescEntry();
 432
 433         if (meth_name.indexOf("#optional") > 0)
 434         {
 435             methDesc.isOptional = true;
 436             meth_name = meth_name.substring(0, meth_name.indexOf("#"));
 437         }
 438
 439         if (meth_name.endsWith("()"))
 440         {
 441             methDesc.EntryType = "method";
 442             entryType = "interface";
 443         }
 444         else
 445         {
 446             methDesc.EntryType = "property";
 447             entryType = "service";
 448         }
 449
 450         methDesc.entryName = meth_name;
 451         methDesc.isToTest = true;
 452
 453
 454         String withoutHash = ifc_name;
 455
 456         if (ifc_name.indexOf("#optional") > 0)
 457         {
 458             withoutHash = ifc_name.substring(0, ifc_name.indexOf("#"));
 459         }
 460
 461         methDesc.longName = parent.entryName + "::" + withoutHash + "::" + meth_name;
 462
 463         return methDesc;
 464     }
 465
 466     /**
 467      * This method ensures that XComponent will be the last in the list of interfaces
 468      */
 469     protected static Object[] makeArray(ArrayList<DescEntry> entries)
 470     {
 471         Object[] entriesArray = entries.toArray();
 472         ArrayList<Object> returnArray = new ArrayList<Object>();
 473         Object addAtEnd = null;
 474
 475         for (int k = 0; k < entriesArray.length; k++)
 476         {
 477             DescEntry entry = (DescEntry) entriesArray[k];
 478
 479             if (entry.entryName.equals("ifc.lang._XComponent"))
 480             {
 481                 addAtEnd = entry;
 482             }
 483             else
 484             {
 485                 returnArray.add(entry);
 486             }
 487         }
 488
 489         if (addAtEnd != null)
 490         {
 491             returnArray.add(addAtEnd);
 492         }
 493
 494         return returnArray.toArray();
 495     }
 496
 497     protected static DescEntry setErrorDescription(DescEntry entry,
 498             String ErrorMsg)
 499     {
 500         if (entry == null)
 501         {
 502             entry = new DescEntry();
 503         }
 504         entry.hasErrorMsg = true;
 505         entry.ErrorMsg = "Error while getting description for test '" +
 506                 fullJob + "' as an API test: " + ErrorMsg;
 507
 508         return entry;
 509     }
 510
 511     protected static DescEntry[] getDescArray(Object[] list)
 512     {
 513         DescEntry[] entries = new DescEntry[list.length];
 514
 515         for (int i = 0; i < list.length; i++)
 516         {
 517             entries[i] = (DescEntry) list[i];
 518         }
 519
 520         return entries;
 521     }
 522
 523     protected DescEntry getFromClassPath(String aEntry, boolean debug)
 524     {
 525         int dotindex = aEntry.indexOf('.');
 526
 527         if (dotindex == -1)
 528         {
 529             return null;
 530         }
 531
 532         String module = null;
 533         String shortName = null;
 534
 535         if (aEntry.indexOf(".uno") == -1)
 536         {
 537             module = aEntry.substring(0, aEntry.indexOf('.'));
 538             shortName = aEntry.substring(aEntry.indexOf('.') + 1);
 539         }
 540         else
 541         {
 542             module = aEntry.substring(0, aEntry.lastIndexOf('.'));
 543             shortName = aEntry.substring(aEntry.lastIndexOf('.') + 1);
 544         }
 545
 546         DescEntry theEntry = new DescEntry();
 547         theEntry.entryName = aEntry;
 548         theEntry.longName = aEntry;
 549         theEntry.isOptional = false;
 550         theEntry.EntryType = "component";
 551         theEntry.isToTest = true;
 552
 553         BufferedReader csvFile = null;
 554
 555         java.net.URL url = this.getClass().getResource("/objdsc/" + module);
 556
 557         if (url == null)
 558         {
 559             return setErrorDescription(theEntry,
 560                     "couldn't find module '" + module + "'");
 561         }
 562
 563         try
 564         {
 565             java.net.URLConnection con = url.openConnection();
 566
 567             String sEndsWithCSVName = "." + shortName.trim() + ".csv";
 568             if (con instanceof java.net.JarURLConnection)
 569             {
 570                 // get Jar file from connection
 571                 java.util.jar.JarFile f = ((java.net.JarURLConnection) con).getJarFile();
 572
 573                 // Enumerate over all entries
 574                 java.util.Enumeration<JarEntry> e = f.entries();
 575
 576                 String sStartModule = "/" + module + "/";
 577                 while (e.hasMoreElements())
 578                 {
 579
 580                     String entry = e.nextElement().toString();
 581
 582 //                    if (debug) {
 583 //                        System.out.println("### Read from connetion: " + entry);
 584 //                    }
 585
 586                     if ((entry.lastIndexOf(sStartModule) != -1) &&
 587                             entry.endsWith(sEndsWithCSVName))
 588                     {
 589                         InputStream input = this.getClass().getResourceAsStream("/" + entry);
 590                         csvFile = new BufferedReader(new InputStreamReader(input));
 591                         break;
 592                     }
 593                 }
 594             }
 595             else
 596             {
 597                 InputStream in = con.getInputStream();
 598                 java.io.BufferedReader buf = new java.io.BufferedReader(new InputStreamReader(in));
 599                 boolean found = false;
 600
 601                 while (buf.ready() && !found)
 602                 {
 603                     String entry = buf.readLine();
 604
 605                     if (entry.endsWith(sEndsWithCSVName))
 606                     {
 607                         System.out.println("FOUND  ####");
 608                         InputStream input = this.getClass().getResourceAsStream("/objdsc/" +
 609                                 module +
 610                                 "/" +
 611                                 entry);
 612                         csvFile = new BufferedReader(
 613                                 new InputStreamReader(input));
 614                         found = true;
 615                     }
 616                 }
 617
 618                 buf.close();
 619             }
 620         }
 621         catch (java.io.IOException e)
 622         {
 623             e.printStackTrace();
 624         }
 625
 626         if (csvFile == null)
 627         {
 628             return setErrorDescription(theEntry,
 629                     "couldn't find component '" +
 630                     theEntry.entryName + "'");
 631         }
 632
 633         DescEntry[] subEntries = getSubEntries(csvFile, theEntry, debug);
 634
 635         theEntry.SubEntryCount = subEntries.length;
 636         theEntry.SubEntries = subEntries;
 637
 638         return theEntry;
 639     }
 640
 641     protected static DescEntry getFromDirectory(String descPath, String entry,
 642             boolean debug)
 643     {
 644         int dotindex = entry.indexOf('.');
 645
 646         if (dotindex == -1)
 647         {
 648             return null;
 649         }
 650
 651         String fs = System.getProperty("file.separator");
 652         String module = null;
 653         String shortName = null;
 654
 655         if (entry.indexOf(".uno") == -1)
 656         {
 657             module = entry.substring(0, entry.indexOf('.'));
 658             shortName = entry.substring(entry.indexOf('.') + 1);
 659         }
 660         else
 661         {
 662             module = entry.substring(0, entry.lastIndexOf('.'));
 663             shortName = entry.substring(entry.lastIndexOf('.') + 1);
 664         }
 665
 666         DescEntry aEntry = new DescEntry();
 667         aEntry.entryName = entry;
 668         aEntry.longName = entry;
 669         aEntry.isOptional = false;
 670         aEntry.EntryType = "component";
 671         aEntry.isToTest = true;
 672
 673         if (debug)
 674         {
 675             System.out.println("Parsing Description Path: " + descPath);
 676             System.out.println("Searching module: " + module);
 677             System.out.println("For the Component " + shortName);
 678         }
 679
 680         File modPath = new File(descPath + fs + module);
 681
 682         if (!modPath.exists())
 683         {
 684             return setErrorDescription(aEntry,
 685                     "couldn't find module '" + module + "'");
 686         }
 687
 688         String[] files = modPath.list();
 689         String found = "none";
 690
 691         for (int i = 0; i < files.length; i++)
 692         {
 693             if (files[i].endsWith("." + shortName + ".csv"))
 694             {
 695                 found = files[i];
 696                 System.out.println("found " + found);
 697                 break;
 698             }
 699         }
 700
 701         if (found.equals("none"))
 702         {
 703             return setErrorDescription(aEntry,
 704                     "couldn't find component '" + entry + "'");
 705         }
 706
 707         String aUrl = descPath + fs + module + fs + found;
 708
 709         BufferedReader csvFile = null;
 710
 711         try
 712         {
 713             csvFile = new BufferedReader(new FileReader(aUrl));
 714         }
 715         catch (java.io.FileNotFoundException fnfe)
 716         {
 717             return setErrorDescription(aEntry, "couldn't find file '" + aUrl + "'");
 718         }
 719
 720         DescEntry[] subEntries = getSubEntries(csvFile, aEntry, debug);
 721
 722         aEntry.SubEntryCount = subEntries.length;
 723         aEntry.SubEntries = subEntries;
 724
 725         return aEntry;
 726     }
 727
 728     protected ArrayList<String> getSubInterfaces(String job)
 729     {
 730         ArrayList<String> namesList = new ArrayList<String>();
 731         StringTokenizer st = new StringTokenizer(job, ",");
 732
 733         for (; st.hasMoreTokens();)
 734         {
 735             String token = st.nextToken();
 736
 737             if (token.indexOf(".") < 0)
 738             {
 739                 namesList.add(token);
 740             }
 741         }
 742
 743         return namesList;
 744     }
 745
 746     protected ArrayList<String> getSubObjects(String job)
 747     {
 748         ArrayList<String> namesList = new ArrayList<String>();
 749         StringTokenizer st = new StringTokenizer(job, ",");
 750
 751         for (; st.hasMoreTokens();)
 752         {
 753             namesList.add(st.nextToken());
 754         }
 755
 756         return namesList;
 757     }
 758
 759     protected String[] createScenario(String descPath, String job,
 760             boolean debug)
 761     {
 762         String[] scenario = null;
 763
 764         if (descPath != null)
 765         {
 766             if (debug)
 767             {
 768                 System.out.println("## reading from File " + descPath);
 769             }
 770
 771             scenario = getScenarioFromDirectory(descPath, job, debug);
 772         }
 773         else
 774         {
 775             if (debug)
 776             {
 777                 System.out.println("## reading from jar");
 778             }
 779
 780             scenario = getScenarioFromClassPath(job, debug);
 781         }
 782
 783         return scenario;
 784     }
 785
 786     protected String[] getScenarioFromDirectory(String descPath, String job,
 787             boolean debug)
 788     {
 789         String[] modules = null;
 790         ArrayList<String> componentList = new ArrayList<String>();
 791
 792         if (!job.equals("unknown") && !job.equals("listall"))
 793         {
 794             modules = new String[]
 795                     {
 796                         job
 797                     };
 798         }
 799         else
 800         {
 801             File dirs = new File(descPath);
 802
 803             if (!dirs.exists())
 804             {
 805                 modules = null;
 806             }
 807             else
 808             {
 809                 modules = dirs.list();
 810             }
 811         }
 812
 813         for (int i = 0; i < modules.length; i++)
 814         {
 815             if (!isUnusedModule(modules[i]))
 816             {
 817                 File moduleDir = new File(descPath + System.getProperty("file.separator") + modules[i]);
 818                 if (moduleDir.exists())
 819                 {
 820                     String[] components = moduleDir.list();
 821                     for (int j = 0; j < components.length; j++)
 822                     {
 823                         if (components[j].endsWith(".csv"))
 824                         {
 825                             String toAdd = getComponentForString(components[j], modules[i]);
 826                             toAdd = "-o " + modules[i] + "." + toAdd;
 827                             componentList.add(toAdd);
 828                         }
 829                     }
 830                 }
 831             }
 832         }
 833
 834         String[] scenario = new String[componentList.size()];
 835         Collections.sort(componentList);
 836
 837         for (int i = 0; i < componentList.size(); i++)
 838         {
 839             scenario[i] = componentList.get(i);
 840         }
 841
 842         return scenario;
 843
 844     }
 845
 846     protected String[] getScenarioFromClassPath(String job, boolean debug)
 847     {
 848         String subdir = "/";
 849
 850         if (!job.equals("unknown") && !job.equals("listall"))
 851         {
 852             subdir += job;
 853         }
 854
 855         java.net.URL url = this.getClass().getResource("/objdsc" + subdir);
 856
 857         if (url == null)
 858         {
 859             return null;
 860         }
 861
 862         ArrayList<String> scenarioList = new ArrayList<String>();
 863
 864         try
 865         {
 866             java.net.URLConnection con = url.openConnection();
 867
 868             if (con instanceof java.net.JarURLConnection)
 869             {
 870                 // get Jar file from connection
 871                 java.util.jar.JarFile f = ((java.net.JarURLConnection) con).getJarFile();
 872
 873                 // Enumerate over all entries
 874                 java.util.Enumeration<JarEntry> e = f.entries();
 875
 876                 while (e.hasMoreElements())
 877                 {
 878                     String entry = e.nextElement().toString();
 879
 880                     if (entry.startsWith("objdsc" + subdir) &&
 881                             (entry.indexOf("CVS") < 0) &&
 882                             !entry.endsWith("/"))
 883                     {
 884                         int startMod = entry.indexOf("/");
 885                         int endMod = entry.lastIndexOf("/");
 886                         String module = entry.substring(startMod + 1, endMod);
 887                         String component = getComponentForString(
 888                                 entry.substring(endMod + 1,
 889                                 entry.length()),
 890                                 module);
 891
 892                         if (!isUnusedModule(module))
 893                         {
 894                             scenarioList.add("-o " + module + "." +
 895                                     component);
 896                         }
 897                     }
 898                 }
 899             }
 900         }
 901         catch (java.io.IOException e)
 902         {
 903             e.printStackTrace();
 904         }
 905
 906         String[] scenario = new String[scenarioList.size()];
 907         Collections.sort(scenarioList);
 908
 909         for (int i = 0; i < scenarioList.size(); i++)
 910         {
 911             scenario[i] = scenarioList.get(i);
 912         }
 913
 914         return scenario;
 915     }
 916
 917     protected String getComponentForString(String full, String module)
 918     {
 919         String component = "";
 920
 921
 922         //cutting .csv
 923         full = full.substring(0, full.length() - 4);
 924
 925         //cutting component
 926         int lastdot = full.lastIndexOf(".");
 927         component = full.substring(lastdot + 1, full.length());
 928
 929         if (module.equals("file") || module.equals("xmloff"))
 930         {
 931             String withoutComponent = full.substring(0, lastdot);
 932             int preLastDot = withoutComponent.lastIndexOf(".");
 933             component = withoutComponent.substring(preLastDot + 1,
 934                     withoutComponent.length()) +
 935                     "." + component;
 936         }
 937
 938         return component;
 939     }
 940
 941     protected boolean isUnusedModule(String moduleName)
 942     {
 943         ArrayList<String> removed = new ArrayList<String>();
 944         removed.add("acceptor");
 945         removed.add("brdgfctr");
 946         removed.add("connectr");
 947         removed.add("corefl");
 948         removed.add("cpld");
 949         removed.add("defreg");
 950         removed.add("dynamicloader");
 951         removed.add("impreg");
 952         removed.add("insp");
 953         removed.add("inv");
 954         removed.add("invadp");
 955         removed.add("javaloader");
 956         removed.add("jen");
 957         removed.add("namingservice");
 958         removed.add("proxyfac");
 959         removed.add("rdbtdp");
 960         removed.add("remotebridge");
 961         removed.add("simreg");
 962         removed.add("smgr");
 963         removed.add("stm");
 964         removed.add("tcv");
 965         removed.add("tdmgr");
 966         removed.add("ucprmt");
 967         removed.add("uuresolver");
 968
 969         return removed.contains(moduleName);
 970     }
 971 }