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