1 /*
   2  * $Id$
   3  *
   4  * Copyright (c) 1996, 2009, 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.File;
  30 import java.util.HashMap;
  31 import java.util.Iterator;
  32 import java.util.Map;
  33 
  34 import com.sun.javatest.TestEnvironment;
  35 import com.sun.javatest.util.I18NResourceBundle;
  36 import com.sun.javatest.util.StringArray;
  37 
  38 /**
  39  * This class allows a new tag "@expand" which allows a single test
  40  * description to be expanded into multiple test descriptions using
  41  * variable substitution.  Variables are declared in the .jte file.
  42  *
  43  * The list of valid entries is identical to those found for JCK.
  44  * There is no list of pre-defined keywords.  If keyword checking
  45  * is needed, then the list of allowed keywords must be
  46  * provided via the <code>-allowKeyword</code> option.
  47  *
  48  * @see TagTestFinder
  49  */
  50 public class ExpandTestFinder extends TagTestFinder
  51 {
  52     //--------------------------------------------------------------------------
  53 
  54     // This code is only needed to ensure that this test finder
  55     // behaves the same as JCKTagTestFinder.  If that finder ever
  56     // derives from this one, it may be removed.
  57 
  58     public ExpandTestFinder() {
  59         validEntries = initTable(stdValidEntries);
  60         validEntries = addTableItem(validEntries, "test", TRUE);
  61         validKeywords = initTable(stdValidKeywords);
  62         validKeywords = initTable(new String[] { });
  63         addExtension(".jasm", JavaCommentStream.class);
  64         addExtension(".jcod", JavaCommentStream.class);
  65     } // ExpandTestFinder()
  66 
  67     protected int decodeArg(String[] args, int i) throws Fault {
  68         if (args[i].equals("-verify")) {
  69             verify = true;
  70             return 1;
  71         }
  72         else if (args[i].equals("-allowEntry")) {
  73             String e = args[i+1];
  74             validEntries.put(e.toLowerCase(), e);
  75             return 2;
  76         }
  77         else if (args[i].equals("-allowKeyword")) {
  78             String k = args[i+1];
  79             validKeywords.put(k.toLowerCase(), k);
  80             return 2;
  81         }
  82         else
  83             return super.decodeArg(args, i);
  84     } // decodeArg()
  85 
  86     private Map<String, String> initTable(String[] entries) {
  87         Map<String, String> map = new HashMap<>();
  88         for (int i = 0; i < entries.length; i++)
  89             map.put(entries[i].toLowerCase(), entries[i]);
  90         return map;
  91     } // initTable()
  92 
  93     private Map<String, String> addTableItem(Map<String, String> entries, String name, String value) {
  94         entries.put(name, value);
  95         return entries;
  96     } // addTableItem()
  97 
  98     private boolean verify;
  99     private Map<String, String> validEntries;
 100     private Map<String, String> validKeywords;
 101 
 102     private static final String TESTSUITE_HTML = "testsuite.html";
 103     // end of code for JCKTagTestFinder emulation
 104 
 105     //--------------------------------------------------------------------------
 106 
 107     public void init(String [] args, File testSuiteRoot, TestEnvironment env) throws Fault {
 108         // grab all environment variables open for expansion
 109         if (expandVars == null) {
 110             expandVars   = new HashMap<>(3);
 111             expandVarLen = new HashMap<>(3);
 112 
 113             for (Iterator<String> i = env.keys().iterator(); i.hasNext(); ) {
 114                 try {
 115                     String n = (i.next());
 116 
 117                     if (! n.startsWith("expand."))
 118                         continue;
 119                     String[] v =  env.lookup(n);
 120                     String fqvName = n.substring("expand.".length());
 121                     // add to hashtable of fully-qualified varNames
 122                     expandVars.put(fqvName, v);
 123 
 124                     int pos;
 125                     if ((pos = fqvName.indexOf(".")) == -1)
 126                         continue;
 127                     String stem = fqvName.substring(0, pos);
 128 
 129                     // checking lengths of co-joined variables
 130                     Integer len = expandVarLen.get(stem);
 131                     if (len == null) {
 132                         // add to hashtable of valid stems
 133                         expandVarLen.put(stem, new Integer(v.length));
 134                     } else {
 135                         if (v.length != len.intValue()) {
 136                             error(i18n, "expand.lengthMismatch",
 137                                   new Object[] {stem, fqvName.substring(pos+1)} );
 138                         }
 139                     }
 140                 } catch (TestEnvironment.Fault f) {
 141                     error(i18n, "expand.noDefn", f.getMessage());
 142                 }
 143             }
 144         }
 145 
 146         // This part of this method is only needed to ensure that this
 147         // test finder behaves the same as JCKTagTestFinder.  If that
 148         // finder ever derives from this one, it may be removed.
 149         if (testSuiteRoot.isDirectory()) {
 150             File f = new File(testSuiteRoot, TESTSUITE_HTML);
 151             if (!(f.exists() && !f.isDirectory() && f.canRead())) {
 152                 throw new Fault(i18n, "expand.badRootDir",
 153                                 new Object[] {TESTSUITE_HTML, testSuiteRoot.getPath()});
 154             }
 155         }
 156         else {
 157             String name = testSuiteRoot.getName();
 158             if (!name.equals(TESTSUITE_HTML)) {
 159                 throw new Fault(i18n, "expand.badRootFile");
 160             }
 161             // force the test suite root to be the directory
 162             testSuiteRoot = new File(testSuiteRoot.getParent());
 163         }
 164         // end of code for JCKTagTestFinder emulation
 165 
 166         super.init(args, testSuiteRoot, env);
 167     } // init()
 168 
 169     protected void foundTestDescription(Map<String, String> entries, File file, int line) {
 170         // cross-product and loop call up
 171         String origId = entries.get("id");
 172         if (origId == null)
 173             origId = "";
 174         Map<String, Integer> loopVars = new HashMap<>(3);
 175         foundTestDescription_1(entries, file, line, loopVars, origId);
 176     } // foundTestDescription()
 177 
 178     private void foundTestDescription_1(Map<String, String> entries, File file, int line, Map<String, Integer> loopVars, String id) {
 179         for (Iterator<String> iter = entries.keySet().iterator(); iter.hasNext(); ) {
 180             String name  = iter.next();
 181             String value = entries.get(name);
 182 //          System.out.println("------ NAME:  " + name + " VALUE: " + value);
 183 
 184             if (name.equals("title") || name.equals("test") || name.equals("id"))
 185                 // don't tokenize
 186                 continue;
 187 
 188             String [] words = StringArray.split(value);
 189             for (int i = 0; i < words.length; i++) {
 190                 if (words[i].startsWith("$")) {
 191                     String varName = words[i].substring(1);
 192 
 193                     // strip out {}'s
 194                     if (varName.startsWith("{")) {
 195                         if (! varName.endsWith("}")) {
 196                             error(i18n, "expand.missingCloseCurly", words[i]);
 197                             continue;
 198                         }
 199                         varName = varName.substring(1, varName.length()-1);
 200                     }
 201 
 202                     // separate foo.bar into stem=foo and qualifier=bar
 203                     String stem;
 204                     String qualifier;
 205                     int pos;
 206                     if ((pos = varName.indexOf(".")) == -1) {
 207                         stem = varName;
 208                         qualifier = "";
 209                     } else {
 210                         stem = varName.substring(0, pos);
 211                         qualifier = varName.substring(pos+1);
 212                     }
 213 
 214 //                  System.out.println("stem: " + stem + " qual: " + qualifier);
 215 
 216                     if (testStems.get(stem) == null)
 217                         // this is something we shouldn't expand
 218                         continue;
 219 
 220                     String [] valueList;
 221                     if ((valueList = expandVars.get(varName)) == null) {
 222                         //String [] msgs = {"unable to find `expand' definition in environment",
 223                         //words[i]};
 224                         //error(msgs);
 225                         continue;
 226                     }
 227 
 228                     String saveId = id;
 229                     Integer idx = loopVars.get(stem);
 230                     if (idx != null){
 231                         int j = idx.intValue();
 232                         words[i] = valueList[j];
 233 
 234                         id = saveId + "_" + words[i];
 235                         entries.put("id", id);
 236 
 237                         entries.put(name, StringArray.join(words));
 238                     } else {
 239                         for (int j = 0; j < valueList.length; j++) {
 240                             words[i] = valueList[j];
 241 
 242                             id = saveId + "_" + words[i];
 243                             entries.put("id", id);
 244 
 245                             entries.put(name, StringArray.join(words));
 246                             boolean loopy = !(qualifier.equals(""));
 247                             if (loopy) loopVars.put(stem, new Integer(j));
 248                             // clone needed here because we over-wrote words[i]
 249                             foundTestDescription_1(new HashMap<>(entries), file, line,
 250                                                    loopVars, id);
 251                             if (loopy) loopVars.remove(stem);
 252 
 253                         }
 254                         return;
 255                     }
 256                 }
 257             }
 258         }
 259         // clone may not be necessary, check for TestDescription upgrades
 260         // super.foundTestDescription(entries, file, line);
 261         super.foundTestDescription(new HashMap<>(entries), file, line);
 262     } // foundTestDescription_1()
 263 
 264     protected void processEntry(Map<String, String> entries, String name, String value) {
 265 //      System.out.println("NAME: " + name + " VALUE: " + value);
 266         if (name.equals("expand")) {
 267             if (testStems != null) {
 268                 error(i18n, "expand.multipleTags");
 269             }
 270             testStems = new HashMap<>(3);
 271             String [] stems = StringArray.split(value);
 272             for (int i = 0 ; i < stems.length; i++)
 273                 testStems.put(stems[i], TRUE);
 274         } else {
 275 
 276             // This part of this method is only needed to ensure that this
 277             // test finder behaves the same as JCKTagTestFinder.  If that
 278             // finder ever derives from this one, it may be removed.
 279             boolean valid = (validEntries.get(name.toLowerCase()) != null);
 280 
 281             if (verify) {
 282                 if (!valid) {
 283                     error(i18n, "expand.unknownEntry",
 284                           new Object[] {name, getCurrentFile()} );
 285                 }
 286                 if (name.equalsIgnoreCase("keywords")) {
 287                     String[] keys = StringArray.split(value);
 288                     if (keys != null) {
 289                         for (int i = 0; i < keys.length; i++) {
 290                             String key = keys[i];
 291                             // minor modification here to allow no keywords
 292                             //if (validKeywords.get(key.toLowerCase()) == null) {
 293                             if ((validKeywords.size() > 0) && (validKeywords.get(key.toLowerCase()) == null)) {
 294                                 error(i18n, "expand.unknownKeyword",
 295                                       new Object[] {key, getCurrentFile()} );
 296                             }
 297                         }
 298                     }
 299                 }
 300             }
 301 
 302             if (valid)
 303                 entries.put(name, value);
 304             // end of code for JCKTagTestFinder emulation
 305 
 306             // if emulation code is removed, still need to do a put
 307             // super.processEntry(entries, name, value);
 308         }
 309     } // processEntry()
 310 
 311     //----------member variables------------------------------------------------
 312 
 313     private static final String TRUE = "true";
 314     private Map<String, String> testStems = null;
 315     private Map<String, String[]> expandVars;
 316     private Map<String, Integer> expandVarLen;
 317 
 318     private String[] stdValidEntries = {
 319         // required
 320         "keywords",
 321         "source",
 322         "title",
 323         // optional
 324         "context",
 325         "executeArgs",
 326         "executeClass",
 327         "executeNative",
 328         "id",           // defined and used internally by JT Harness
 329         "rmicClasses",
 330         "timeout"
 331     };
 332 
 333     private String[] stdValidKeywords = {
 334         // approved
 335         "compiler",
 336         "runtime",
 337         "positive",
 338         "negative",
 339         "idl_inherit",
 340         "idl_tie",
 341         "interactive",
 342         "jniinvocationapi",
 343         "optionalPJava",
 344         // will eventually be superceded/deprecated
 345         "serial"
 346     };
 347     private static I18NResourceBundle i18n = I18NResourceBundle.getBundleForClass(ExpandTestFinder.class);
 348 }