1 /*
   2  * $Id$
   3  *
   4  * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
   5  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   6  *
   7  * This code is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 only, as
   9  * published by the Free Software Foundation.  Oracle designates this
  10  * particular file as subject to the "Classpath" exception as provided
  11  * by Oracle in the LICENSE file that accompanied this code.
  12  *
  13  * This code is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16  * version 2 for more details (a copy is included in the LICENSE file that
  17  * accompanied this code).
  18  *
  19  * You should have received a copy of the GNU General Public License version
  20  * 2 along with this work; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  22  *
  23  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  24  * or visit www.oracle.com if you need additional information or have any
  25  * questions.
  26  */
  27 package com.sun.javatest.finder;
  28 
  29 import java.io.*;
  30 import java.nio.charset.StandardCharsets;
  31 import java.util.*;
  32 
  33 import com.sun.javatest.TestDescription;
  34 import com.sun.javatest.TestEnvironment;
  35 import com.sun.javatest.TestFinder;
  36 import com.sun.javatest.util.I18NResourceBundle;
  37 import com.sun.javatest.util.StringArray;
  38 
  39 /**
  40  * A TestFinder that delegates to different test finders in different
  41  * areas of the test suite, as described by a special "map" file.
  42  */
  43 public class ChameleonTestFinder extends TestFinder {
  44     /**
  45      * Create an uninitialized ChameleonTestFinder.
  46      */
  47     public ChameleonTestFinder() {
  48         String ic = System.getProperty("javatest.chameleon.ignoreCase");
  49         if (ic != null)
  50             ignoreCase = ic.equals("true");
  51         else {
  52             String os = System.getProperty("os.name");
  53             ignoreCase = os.startsWith("Windows");
  54         }
  55         exclude(excludeNames);
  56     }
  57 
  58     /**
  59      * Exclude all files with a particular name from being scanned.
  60      * This will typically be for directories like SCCS, Codemgr_wsdata, etc
  61      * @param name The name of files to be excluded
  62      */
  63     public void exclude(String name) {
  64         excludeList.put(name, name);
  65     }
  66 
  67     /**
  68      * Exclude all files with particular names from being scanned.
  69      * This will typically be for directories like SCCS, Codemgr_wsdata, etc
  70      * @param names The names of files to be excluded
  71      */
  72     public void exclude(String[] names) {
  73         for (int i = 0; i < names.length; i++) {
  74             String name = names[i];
  75             excludeList.put(name, name);
  76         }
  77     }
  78 
  79     /**
  80      * Check whether or not to ignore case when matching files against entries.
  81      *
  82      * By default, case will be ignored on Windows platforms.
  83      * (<code><font size=-1>System.getProperty("os.name").startsWith("Windows")</font></code>)
  84      * This can be overridden by setting the following system property:
  85      * <pre>
  86      *    -Djavatest.chameleon.ignoreCase=true|false
  87      * </pre>
  88      *
  89      * This in turn can be overridden by using -ignoreCase or -dontIgnoreCase
  90      * in the args to {@link #init init}.
  91      *
  92      * @return  whether or not to ignore case when matching files against entries.
  93      * @see #setIgnoreCase
  94      */
  95     public boolean getIgnoreCase() {
  96         return ignoreCase;
  97     }
  98 
  99     /**
 100      * Set whether or not to ignore case when matching files against entries.
 101      *
 102      * @param b whether or not to ignore case when matching files against entries.
 103      * @see #getIgnoreCase
 104      */
 105     public void setIgnoreCase(boolean b) {
 106         ignoreCase = b;
 107     }
 108     /**
 109      * Generic initialization routine. You can also initialize the test finder
 110      * directly, with {@link #exclude}, {@link #readEntries}, etc.
 111      * @param args An array of strings giving initialization data.
 112      *  The primary option is "-f <em>file</em>" to specify the name
 113      *  of the file describing which test finder to use in which section
 114      *  of the test suite.
 115      * @param testSuiteRoot     The root file of the test suite.
 116      * @param env               This argument is not required by this test finder.
 117      * @throws TestFinder.Fault if an error is found during initialization.
 118      */
 119     public void init(String[] args, File testSuiteRoot, TestEnvironment env) throws Fault {
 120         super.init(args, testSuiteRoot, env);
 121 
 122         if (entryFile == null)
 123             throw new Fault(i18n, "cham.noConfigFile");
 124 
 125         if (!entryFile.isAbsolute())
 126             entryFile = new File(getRootDir(), entryFile.getPath());
 127 
 128         readEntries(entryFile);
 129     }
 130 
 131     /**
 132      * Read the entries in a file which describe which test finder to use
 133      * in which part of the test suite.
 134      * The file is read line by line. If a line is empty or begins with
 135      * a '#' character, the line is ignored. Otherwise the line is broken
 136      * up as follows:<br>
 137      * <em>directory-or-file</em>  <em>finder-class-name</em>  <em>finder-args</em> <em>...</em><br>
 138      * Then, when a file is to be read by the test finder, the entries above are
 139      * checked in the order they were read for an entry whose first word matches
 140      * the beginning of the name of the file to be read. If and when a match
 141      * is found, the test finder delegates the request to the test finder specified
 142      * in the rest of the entry that provided the match.
 143      * @param file              The file containing the entries to be read.
 144      * @throws TestFinder.Fault if a problem occurs while reading the file.
 145      */
 146     public void readEntries(File file) throws Fault {
 147         //System.err.println("reading " + file);
 148         SortedSet<Entry> s = new TreeSet<>(new Comparator<Entry>() {
 149             public int compare(Entry o1, Entry o2) {
 150                 int n = o1.compareTo(o2);
 151                 // this gives us the reverse of the order we want, so ...
 152                 return -n;
 153             }
 154         });
 155 
 156         try (BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(file), StandardCharsets.UTF_8))) {
 157             String line;
 158             int lineNum = 0;
 159             while ((line = in.readLine()) != null) {
 160                 line = line.trim();
 161                 lineNum++;
 162                 if (line.startsWith("#")  ||  line.length() == 0)
 163                     continue;
 164 
 165                 String[] words = StringArray.split(line);
 166                 if (words.length < 2) {
 167                     throw new Fault(i18n, "cham.missingData",
 168                                     new Object[] {new Integer(lineNum), line});
 169                 }
 170 
 171                 String pattern = words[0];
 172                 String finderClassName = words[1];
 173                 String[] finderArgs = new String[words.length - 2];
 174                 System.arraycopy(words, 2, finderArgs, 0, finderArgs.length);
 175                 Entry e = new Entry(pattern, finderClassName, finderArgs);
 176                 s.add(e);
 177             }
 178         }
 179         catch (FileNotFoundException e) {
 180             throw new Fault(i18n, "cham.cantFindFile", file);
 181         }
 182         catch (IOException e) {
 183             throw new Fault(i18n, "cham.ioError",
 184                             new Object[] {file, e});
 185         }
 186 
 187         entryFile = file;
 188         entries = s.toArray(new Entry[s.size()]);
 189 
 190         //for (int i = 0; i < entries.length; i++)
 191         //    System.err.println(entries[i].prefix + "   " + entries[i].suffix);
 192     }
 193 
 194     protected int decodeArg(String[] args, int i) throws Fault {
 195         if (args[i].equals("-f") && i + 1 < args.length) {
 196             entryFile = new File(args[i + 1]);
 197             return 2;
 198         }
 199         else if (args[i].equalsIgnoreCase("-ignoreCase")) {
 200             ignoreCase = true;
 201             return 1;
 202         }
 203         else if (args[i].equalsIgnoreCase("-dontIgnoreCase")) {
 204             ignoreCase = false;
 205             return 1;
 206         }
 207         else
 208             return super.decodeArg(args, i);
 209     }
 210 
 211 
 212     /**
 213      * Scan a file, looking for test descriptions and other files that might
 214      * need to be scanned.  The implementation depends on the type of test
 215      * finder.
 216      * @param file The file to scan
 217      */
 218     protected void scan(File file) {
 219         //System.err.println("SCAN: " + file);
 220         if (file.isDirectory())
 221             scanDirectory(file);
 222         else
 223             scanFile(file);
 224     }
 225 
 226     public File[] getFiles() {
 227         if (currEntry == null)
 228             return super.getFiles();
 229         else if (currEntry.finder == null)
 230             return new File[0];
 231         else
 232             return currEntry.finder.getFiles();
 233     }
 234 
 235     public TestDescription[] getTests() {
 236         if (currEntry == null)
 237             return super.getTests();
 238         else if (currEntry.finder == null)
 239             return new TestDescription[0];
 240         else
 241             return currEntry.finder.getTests();
 242     }
 243 
 244 
 245     //-----internal routines----------------------------------------------------
 246 
 247     /**
 248      * Scan a directory, looking for more files to scan
 249      * @param dir The directory to scan
 250      */
 251     private void scanDirectory(File dir) {
 252         // scan the contents of the directory, checking for
 253         // subdirectories and other files that should be scanned
 254         currEntry = null;
 255         String[] names = dir.list();
 256         for (int i = 0; i < names.length; i++) {
 257             String name = names[i];
 258             // if the file should be ignored, skip it
 259             // This is typically for directories like SCCS etc
 260             if (excludeList.containsKey(name))
 261                 continue;
 262 
 263             foundFile(new File(dir, name));
 264         }
 265     }
 266 
 267     private void scanFile(File file) {
 268         // see if the file matches a registered test finder, and if so
 269         // delegate to that
 270         for (int i = 0; i < entries.length; i++) {
 271             if (entries[i].matches(file)) {
 272                 currEntry = entries[i];
 273                 currEntry.scanFile(file);
 274                 return;
 275             }
 276         }
 277         // no match found
 278         currEntry = null;
 279     }
 280 
 281     private Object newInstance(Class c) throws Fault {
 282         try {
 283             return c.newInstance();
 284         }
 285         catch (InstantiationException e) {
 286             throw new Fault(i18n, "cham.cantCreateClass",
 287                             new Object[] {c.getName(), e});
 288         }
 289         catch (IllegalAccessException e) {
 290             throw new Fault(i18n, "cham.cantAccessClass",
 291                             new Object[] {c.getName(), e});
 292         }
 293     }
 294 
 295     private Class loadClass(String className) throws Fault {
 296         try {
 297             if (loader == null)
 298                 return Class.forName(className);
 299             else
 300                 return loader.loadClass(className);
 301         }
 302         catch (ClassNotFoundException e) {
 303             throw new Fault(i18n, "cham.cantFindClass",
 304                             new Object[] {className, e});
 305         }
 306         catch (IllegalArgumentException e) {
 307             throw new Fault(i18n, "cham.badClassName", className);
 308         }
 309 
 310     }
 311 
 312     private TestEnvironment getEnv() {
 313         return env;
 314     }
 315 
 316     private File entryFile;
 317     private Entry[] entries;
 318     private boolean ignoreCase;
 319     private Entry currEntry;
 320     private ClassLoader loader;
 321     private Map<String, String> excludeList = new HashMap<>();
 322 
 323     private static final String[] excludeNames = {
 324         "SCCS", "deleted_files"
 325     };
 326 
 327     private static I18NResourceBundle i18n = I18NResourceBundle.getBundleForClass(ChameleonTestFinder.class);
 328 
 329     private class Entry {
 330         Entry(String pattern, String finderClassName, String[] finderArgs) {
 331             int star = pattern.indexOf('*');
 332             if (star == -1) {
 333                 prefix = pattern;
 334                 suffix = null;
 335             }
 336             else {
 337                 prefix = pattern.substring(0, star);
 338                 suffix = pattern.substring(star+1);
 339             }
 340             prefix = new File(getRootDir(), prefix.replace('/', File.separatorChar)).getPath();
 341             if (suffix != null)
 342                 suffix = suffix.replace('/', File.separatorChar);
 343 
 344             this.finderClassName = finderClassName;
 345             this.finderArgs = finderArgs;
 346 
 347             //System.err.println("created entry: prefix: " + prefix);
 348             //System.err.println("created entry: suffix: " + suffix);
 349             //System.err.println("created entry:  class: " + finderClassName);
 350             //System.err.println("created entry:   args: " + StringArray.join(finderArgs));
 351         }
 352 
 353         boolean matches(File file) {
 354             //System.err.println("checking " + file);
 355             //System.err.println(" prefix: " + prefix);
 356             //System.err.println(" suffix: " + suffix);
 357 
 358             String p = file.getPath();
 359             int pLen = p.length();
 360             int preLen = prefix.length();
 361 
 362             // if file does not match the prefix, return false
 363             if (!p.regionMatches(ignoreCase, 0, prefix, 0, preLen))
 364                 return false;
 365 
 366             // if there is a suffix, and the suffix is too short or the
 367             // file does not match the prefix, return false
 368             if (suffix != null) {
 369                 int sufLen = suffix.length();
 370 
 371                 if (sufLen > pLen)
 372                     return false;
 373 
 374                 if (!p.regionMatches(ignoreCase, pLen - sufLen, suffix, 0, sufLen))
 375                     return false;
 376             }
 377 
 378             // if we matched the prefix and possible suffix, we're done
 379             return true;
 380         }
 381 
 382         void scanFile(File file) {
 383             if (!initialized)
 384                 init();
 385 
 386             if (finder != null)
 387                 finder.read(file);
 388         }
 389 
 390         private void init() {
 391             try {
 392                 if (!finderClassName.equals("-")) {
 393                     finder = (TestFinder)(newInstance(loadClass(finderClassName)));
 394                     finder.init(finderArgs, getRoot(), getEnv());
 395                 }
 396             }
 397             catch (Fault e) {
 398                 error(i18n, "cham.cantInitClass", e.getMessage());
 399             }
 400             finally {
 401                 initialized = true;
 402             }
 403         }
 404 
 405         int compareTo(Entry other) {
 406             Entry a = this;
 407             Entry b = other;
 408             int apl = a.prefix.length();
 409             int bpl = b.prefix.length();
 410             if (apl < bpl)
 411                 return -1;
 412             else if (apl == bpl) {
 413                 int pc = a.prefix.compareTo(b.prefix);
 414                 if (pc != 0)
 415                     return pc;
 416                 else {
 417                     // prefixes are the same, check the suffixes
 418                     String as = a.suffix;
 419                     String bs = b.suffix;
 420                     if (as == null && bs == null)
 421                         return 0;
 422 
 423                     if (as == null)
 424                         return -1;
 425 
 426                     if (bs == null)
 427                         return +1;
 428 
 429                     return as.compareTo(bs);
 430                 }
 431             }
 432             else
 433                 return +1;
 434         }
 435 
 436         private String prefix;
 437         private String suffix;
 438         private String finderClassName;
 439         private String[] finderArgs;
 440         private TestFinder finder;
 441         private boolean initialized;
 442     }
 443 }