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