Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
  
  
  package org.apache.hadoop.hive.ql;
  
  import static org.apache.hadoop.hive.metastore.MetaStoreUtils.DEFAULT_DATABASE_NAME;
  
  import java.io.File;
  import java.util.Arrays;
  import java.util.Deque;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  import java.util.TreeMap;
  
  
  import  org.apache.hadoop.fs.FileStatus;
  import  org.apache.hadoop.fs.FileSystem;
  import  org.apache.hadoop.fs.Path;
  import  org.apache.hadoop.hbase.zookeeper.MiniZooKeeperCluster;
  import  org.apache.hadoop.hive.cli.CliDriver;
  import  org.apache.hadoop.hive.cli.CliSessionState;
  import  org.apache.hadoop.hive.metastore.MetaStoreUtils;
  import  org.apache.hadoop.mapred.MiniMRCluster;
  import  org.apache.hadoop.mapred.SequenceFileInputFormat;
  import  org.apache.hadoop.mapred.SequenceFileOutputFormat;
  import  org.apache.hadoop.mapred.TextInputFormat;
  import  org.apache.zookeeper.ZooKeeper;

QTestUtil.
  
  public class QTestUtil {
  
    private String testWarehouse;
    private final String tmpdir= System.getProperty("test.tmp.dir") ;
    private final Path tmppath = new Path();
  
  
    private final String testFiles;
    private final String outDir;
    private final String logDir;
    private final TreeMap<StringStringqMap;
    private final Set<StringqSkipSet;
    public static final HashSet<StringsrcTables = new HashSet<String>
      (Arrays.asList(new String [] {
          "src""src1""srcbucket""srcbucket2""src_json""src_thrift",
         "src_sequencefile""srcpart"
       }));
 
   private ParseDriver pd;
   private Hive db;
   protected HiveConf conf;
   private Driver drv;
   private SemanticAnalyzer sem;
   private FileSystem fs;
   private boolean overWrite;
   private CliDriver cliDriver;
   private MiniMRCluster mr = null;
   private HadoopShims.MiniDFSShim dfs = null;
   private boolean miniMr = false;
   private String hadoopVer = null;
   private QTestSetup setup = null;
 
   public boolean deleteDirectory(File path) {
     if (path.exists()) {
       File[] files = path.listFiles();
       for (File file : files) {
         if (file.isDirectory()) {
           deleteDirectory(file);
         } else {
           file.delete();
         }
       }
     }
     return (path.delete());
   }
 
   public void copyDirectoryToLocal(Path src, Path destthrows Exception {
 
     FileSystem srcFs = src.getFileSystem();
     FileSystem destFs = dest.getFileSystem();
     if (srcFs.exists(src)) {
       FileStatus[] files = srcFs.listStatus(src);
       for (FileStatus file : files) {
         String name = file.getPath().getName();
         Path dfs_path = file.getPath();
         Path local_path = new Path(destname);
 
         // If this is a source table we do not copy it out
         if (.contains(name)) {
           continue;
         }
 
         if (file.isDir()) {
           if (!destFs.exists(local_path)) {
             destFs.mkdirs(local_path);
           }
           copyDirectoryToLocal(dfs_pathlocal_path);
         } else {
           srcFs.copyToLocalFile(dfs_pathlocal_path);
         }
       }
     }
   }
 
   static Pattern mapTok = Pattern.compile("(\\.?)(.*)_map_(.*)");
   static Pattern reduceTok = Pattern.compile("(.*)(reduce_[^\\.]*)((\\..*)?)");
 
   public void normalizeNames(File paththrows Exception {
     if (path.isDirectory()) {
       File[] files = path.listFiles();
       for (File file : files) {
         normalizeNames(file);
       }
     } else {
       // System.out.println("Trying to match: " + path.getPath());
       Matcher m = .matcher(path.getName());
       if (m.matches()) {
         String name = m.group(1) + "reduce" + m.group(3);
         // System.out.println("Matched new name: " + name);
         path.renameTo(new File(path.getParent(), name));
       } else {
         m = .matcher(path.getName());
         if (m.matches()) {
           String name = m.group(1) + "map_" + m.group(3);
           // System.out.println("Matched new name: " + name);
           path.renameTo(new File(path.getParent(), name));
         }
       }
     }
   }
 
   public QTestUtil(String outDirString logDirthrows Exception {
     this(outDirlogDirfalse"0.20");
   }
 
   private String getHadoopMainVersion(String input) {
     if (input == null) {
       return null;
     }
     Pattern p = Pattern.compile("^(\\d+\\.\\d+).*");
     Matcher m = p.matcher(input);
     if (m.matches()) {
       return m.group(1);
     }
     return null;
   }
 
   public void initConf() throws Exception {
     if () {
       assert  != null;
       assert  != null;
       // set fs.default.name to the uri of mini-dfs
       .setVar(...getFileSystem().getUri().toString());
       // hive.metastore.warehouse.dir needs to be set relative to the mini-dfs
                   (new Path(.getFileSystem().getUri().toString(),
                             "/build/ql/test/data/warehouse/")).toString());
       .setVar(.."localhost:" + .getJobTrackerPort());
     }
   }
 
   public QTestUtil(String outDirString logDirboolean miniMrString hadoopVer)
     throws Exception {
     this. = outDir;
     this. = logDir;
      = new HiveConf(Driver.class);
     this. = miniMr;
     this. = getHadoopMainVersion(hadoopVer);
      = new TreeMap<StringString>();
      = new HashSet<String>();
 
     if (miniMr) {
        = ShimLoader.getHadoopShims().getMiniDfs(, 4, truenull);
       FileSystem fs = .getFileSystem();
        = new MiniMRCluster(4, fs.getUri().toString(), 1);
     }
 
     initConf();
 
      = .get("test.data.files").replace('\\''/')
         .replace("c:""");
 
     String ow = System.getProperty("test.output.overwrite");
      = false;
     if ((ow != null) && ow.equalsIgnoreCase("true")) {
        = true;
     }
 
      = new QTestSetup();
     .preTest();
     init();
   }
 
   public void shutdown() throws Exception {
     cleanUp();
 
     if ( != null) {
       .shutdown();
        = null;
     }
 
     if ( != null) {
       .shutdown();
        = null;
     }
   }
 
   public void addFile(String qFilethrows Exception {
 
     File qf = new File(qFile);
     addFile(qf);
   }
 
   public void addFile(File qfthrows Exception {
 
     FileInputStream fis = new FileInputStream(qf);
     BufferedInputStream bis = new BufferedInputStream(fis);
     DataInputStream dis = new DataInputStream(bis);
     StringBuilder qsb = new StringBuilder();
 
     // Look for a hint to not run a test on some Hadoop versions
     Pattern pattern = Pattern.compile("-- EXCLUDE_HADOOP_MAJOR_VERSIONS(.*)");
 
 
     // Read the entire query
     boolean excludeQuery = false;
     String hadoopVer = ShimLoader.getMajorVersion();
     while (dis.available() != 0) {
       String line = dis.readLine();
 
       // While we are reading the lines, detect whether this query wants to be
       // excluded from running because the Hadoop version is incorrect
       Matcher matcher = pattern.matcher(line);
       if (matcher.find()) {
         String group = matcher.group();
         int start = group.indexOf('(');
         int end = group.indexOf(')');
         assert end > start;
         // versions might be something like '0.17, 0.19'
         String versions = group.substring(start+1, end);
 
         Set<StringexcludedVersionSet = new HashSet<String>();
         for (String s : versions.split("\\,")) {
           s = s.trim();
           excludedVersionSet.add(s);
         }
         if (excludedVersionSet.contains(hadoopVer)) {
           excludeQuery = true;
         }
       }
       qsb.append(line + "\n");
     }
     .put(qf.getName(), qsb.toString());
     if(excludeQuery) {
       ..println("Due to the Hadoop Version ("hadoopVer + "), " +
           "adding query " + qf.getName() + " to the set of tests to skip");
       .add(qf.getName());
      }
     dis.close();
   }

  
Clear out any side effects of running tests
 
   public void clearPostTestEffects () throws Exception {
     .postTest();
   }

  
Clear out any side effects of running tests
 
   public void clearTestSideEffects () throws Exception {
     // Delete any tables other than the source tables
     // and any databases other than the default database.
     for (String dbName : .getAllDatabases()) {
       .setCurrentDatabase(dbName);
       for (String tblName : .getAllTables()) {
         if (!DEFAULT_DATABASE_NAME.equals(dbName) || !.contains(tblName)) {
           .dropTable(dbNametblName);
         }
       }
       if (!DEFAULT_DATABASE_NAME.equals(dbName)) {
         .dropDatabase(dbName);
       }
     }
     .setCurrentDatabase(DEFAULT_DATABASE_NAME);
 
     List<StringroleNames = .getAllRoleNames();
       for (String roleName : roleNames) {
         .dropRole(roleName);
     }
     // allocate and initialize a new conf since a test can
     // modify conf by using 'set' commands
      = new HiveConf (Driver.class);
     initConf();
     .preTest();
   }
 
   public void cleanUp() throws Exception {
     // Drop any tables that remain due to unsuccessful runs
     for (String s : new String[] {"src""src1""src_json""src_thrift",
         "src_sequencefile""srcpart""srcbucket""srcbucket2""dest1",
         "dest2""dest3""dest4""dest4_sequencefile""dest_j1""dest_j2",
         "dest_g1""dest_g2""fetchtask_ioexception"}) {
       .dropTable(MetaStoreUtils.DEFAULT_DATABASE_NAME, s);
     }
 
     // delete any contents in the warehouse dir
     Path p = new Path();
     FileSystem fs = p.getFileSystem();
     FileStatus [] ls = fs.listStatus(p);
     for (int i=0; (ls != null) && (i<ls.length); i++) {
       fs.delete(ls[i].getPath(), true);
     }
 
     FunctionRegistry.unregisterTemporaryUDF("test_udaf");
     FunctionRegistry.unregisterTemporaryUDF("test_error");
     .tearDown();
   }
 
   private void runLoadCmd(String loadCmdthrows Exception {
     int ecode = 0;
     ecode = .run(loadCmd).getResponseCode();
     .close();
     if (ecode != 0) {
       throw new Exception("load command: " + loadCmd
           + " failed with exit code= " + ecode);
     }
     return;
   }
 
   private void runCreateTableCmd(String createTableCmdthrows Exception {
     int ecode = 0;
     ecode = .run(createTableCmd).getResponseCode();
     if (ecode != 0) {
       throw new Exception("create table command: " + createTableCmd
           + " failed with exit code= " + ecode);
     }
 
     return;
   }
 
   public void createSources() throws Exception {
 
 
     // Create a bunch of tables with columns key and value
     LinkedList<Stringcols = new LinkedList<String>();
     cols.add("key");
     cols.add("value");
 
     LinkedList<Stringpart_cols = new LinkedList<String>();
     part_cols.add("ds");
     part_cols.add("hr");
     .createTable("srcpart"colspart_cols, TextInputFormat.class,
         IgnoreKeyTextOutputFormat.class);
 
     Path fpath;
     HashMap<StringStringpart_spec = new HashMap<StringString>();
     for (String ds : new String[] {"2008-04-08""2008-04-09"}) {
       for (String hr : new String[] {"11""12"}) {
         part_spec.clear();
         part_spec.put("ds"ds);
         part_spec.put("hr"hr);
         // System.out.println("Loading partition with spec: " + part_spec);
         // db.createPartition(srcpart, part_spec);
         fpath = new Path("kv1.txt");
         // db.loadPartition(fpath, srcpart.getName(), part_spec, true);
         runLoadCmd("LOAD DATA LOCAL INPATH '" + fpath.toString()
             + "' OVERWRITE INTO TABLE srcpart PARTITION (ds='" + ds + "',hr='"
             + hr + "')");
       }
     }
     ArrayList<StringbucketCols = new ArrayList<String>();
     bucketCols.add("key");
     runCreateTableCmd("CREATE TABLE srcbucket(key int, value string) CLUSTERED BY (key) INTO 2 BUCKETS STORED AS TEXTFILE");
     // db.createTable("srcbucket", cols, null, TextInputFormat.class,
     // IgnoreKeyTextOutputFormat.class, 2, bucketCols);
     for (String fname : new String[] {"srcbucket0.txt""srcbucket1.txt"}) {
       fpath = new Path(fname);
       runLoadCmd("LOAD DATA LOCAL INPATH '" + fpath.toString()
           + "' INTO TABLE srcbucket");
     }
 
     runCreateTableCmd("CREATE TABLE srcbucket2(key int, value string) "
         + "CLUSTERED BY (key) INTO 4 BUCKETS STORED AS TEXTFILE");
     // db.createTable("srcbucket", cols, null, TextInputFormat.class,
     // IgnoreKeyTextOutputFormat.class, 2, bucketCols);
     for (String fname : new String[] {"srcbucket20.txt""srcbucket21.txt",
         "srcbucket22.txt""srcbucket23.txt"}) {
       fpath = new Path(fname);
       runLoadCmd("LOAD DATA LOCAL INPATH '" + fpath.toString()
           + "' INTO TABLE srcbucket2");
     }
 
     for (String tname : new String[] {"src""src1"}) {
       .createTable(tnamecolsnull, TextInputFormat.class,
           IgnoreKeyTextOutputFormat.class);
     }
     .createTable("src_sequencefile"colsnull,
         SequenceFileInputFormat.class, SequenceFileOutputFormat.class);
 
     Table srcThrift = new Table(.getCurrentDatabase(), "src_thrift");
     srcThrift.setInputFormatClass(SequenceFileInputFormat.class.getName());
     srcThrift.setOutputFormatClass(SequenceFileOutputFormat.class.getName());
     srcThrift.setSerializationLib(ThriftDeserializer.class.getName());
         .getName());
         TBinaryProtocol.class.getName());
     .createTable(srcThrift);
 
     LinkedList<Stringjson_cols = new LinkedList<String>();
     json_cols.add("json");
     .createTable("src_json"json_colsnull, TextInputFormat.class,
         IgnoreKeyTextOutputFormat.class);
 
     // load the input data into the src table
     fpath = new Path("kv1.txt");
     runLoadCmd("LOAD DATA LOCAL INPATH '" + fpath.toString() + "' INTO TABLE src");
 
     // load the input data into the src table
     fpath = new Path("kv3.txt");
     runLoadCmd("LOAD DATA LOCAL INPATH '" + fpath.toString() + "' INTO TABLE src1");
 
     // load the input data into the src_sequencefile table
     fpath = new Path("kv1.seq");
     runLoadCmd("LOAD DATA LOCAL INPATH '" + fpath.toString()
         + "' INTO TABLE src_sequencefile");
 
     // load the input data into the src_thrift table
     fpath = new Path("complex.seq");
     runLoadCmd("LOAD DATA LOCAL INPATH '" + fpath.toString()
         + "' INTO TABLE src_thrift");
 
     // load the json data into the src_json table
     fpath = new Path("json.txt");
     runLoadCmd("LOAD DATA LOCAL INPATH '" + fpath.toString()
         + "' INTO TABLE src_json");
 
   }
 
   public void init() throws Exception {
     // System.out.println(conf.toString());
     // conf.logVars(System.out);
     // System.out.flush();
 
     SessionState.start();
      = Hive.get();
      = FileSystem.get();
      = new Driver();
     .init();
      = new ParseDriver();
      = new SemanticAnalyzer();
   }
 
   public void init(String tnamethrows Exception {
     cleanUp();
     createSources();
 
     LinkedList<Stringcols = new LinkedList<String>();
     cols.add("key");
     cols.add("value");
 
     LinkedList<Stringpart_cols = new LinkedList<String>();
     part_cols.add("ds");
     part_cols.add("hr");
 
     .createTable("dest1"colsnull, TextInputFormat.class,
         IgnoreKeyTextOutputFormat.class);
     .createTable("dest2"colsnull, TextInputFormat.class,
         IgnoreKeyTextOutputFormat.class);
 
     .createTable("dest3"colspart_cols, TextInputFormat.class,
         IgnoreKeyTextOutputFormat.class);
     Table dest3 = .getTable("dest3");
 
     HashMap<StringStringpart_spec = new HashMap<StringString>();
     part_spec.put("ds""2008-04-08");
     part_spec.put("hr""12");
     .createPartition(dest3part_spec);
 
     .createTable("dest4"colsnull, TextInputFormat.class,
         IgnoreKeyTextOutputFormat.class);
     .createTable("dest4_sequencefile"colsnull,
         SequenceFileInputFormat.class, SequenceFileOutputFormat.class);
   }
 
   public void cliInit(String tnamethrows Exception {
     cliInit(tnametrue);
   }
 
   public void cliInit(String tnameboolean recreatethrows Exception {
     if (recreate) {
       cleanUp();
       createSources();
     }
 
     "org.apache.hadoop.hive.ql.security.DummyAuthenticator");
     CliSessionState ss = new CliSessionState();
     assert ss != null;
     ss.in = .;
 
     File qf = new File(tname);
     File outf = null;
     outf = new File();
     outf = new File(outfqf.getName().concat(".out"));
     FileOutputStream fo = new FileOutputStream(outf);
     ss.out = new PrintStream(fotrue"UTF-8");
     ss.err = ss.out;
     ss.setIsSilent(true);
     SessionState oldSs = SessionState.get();
     if (oldSs != null && oldSs.out != null && oldSs.out != .) {
       oldSs.out.close();
     }
     SessionState.start(ss);
 
      = new CliDriver();
     if (tname.equals("init_file.q")) {
       ss.initFiles.add("../data/scripts/test_init_file.sql");
     }
     .processInitFiles(ss);
   }
 
   private CliSessionState startSessionState()
 
         "org.apache.hadoop.hive.ql.security.DummyAuthenticator");
 
     CliSessionState ss = new CliSessionState();
     assert ss != null;
 
     SessionState.start(ss);
     return ss;
   }
 
   public int executeOne(String tname) {
     String q = .get(tname);
 
     if (q.indexOf(";") == -1) {
       return -1;
     }
 
     String q1 = q.substring(0, q.indexOf(";") + 1);
     String qrest = q.substring(q.indexOf(";") + 1);
     .put(tnameqrest);
 
     ..println("Executing " + q1);
     return .processLine(q1);
   }
 
   public int execute(String tname) {
     return .run(.get(tname)).getResponseCode();
   }
 
   public int executeClient(String tname) {
     return .processLine(.get(tname));
   }
 
   public boolean shouldBeSkipped(String tname) {
     return .contains(tname);
   }
 
   public void convertSequenceFileToTextFile() throws Exception {
     // Create an instance of hive in order to create the tables
      = Hive.get();
     // Create dest4 to replace dest4_sequencefile
     LinkedList<Stringcols = new LinkedList<String>();
     cols.add("key");
     cols.add("value");
 
     // Move all data from dest4_sequencefile to dest4
     
         .run("FROM dest4_sequencefile INSERT OVERWRITE TABLE dest4 SELECT dest4_sequencefile.*");
 
     // Drop dest4_sequencefile
     .dropTable(MetaStoreUtils.DEFAULT_DATABASE_NAME, "dest4_sequencefile",
         truetrue);
   }
 
   public int checkNegativeResults(String tnameException ethrows Exception {
 
     File qf = new File(tname);
     String expf = outPath(.toString(), tname.concat(".out"));
 
     File outf = null;
     outf = new File();
     outf = new File(outfqf.getName().concat(".out"));
 
     FileWriter outfd = new FileWriter(outf);
     if (e instanceof ParseException) {
       outfd.write("Parse Error: ");
     } else if (e instanceof SemanticException) {
       outfd.write("Semantic Exception: \n");
     } else {
       throw e;
     }
 
     outfd.write(e.getMessage());
     outfd.close();
 
     String cmdLine = "diff " + outf.getPath() + " " + expf;
     ..println(cmdLine);
 
     Process executor = Runtime.getRuntime().exec(cmdLine);
 
     StreamPrinter outPrinter = new StreamPrinter(
         executor.getInputStream(), null, SessionState.getConsole().getChildOutStream());
     StreamPrinter errPrinter = new StreamPrinter(
         executor.getErrorStream(), null, SessionState.getConsole().getChildErrStream());
 
     outPrinter.start();
     errPrinter.start();
 
     int exitVal = executor.waitFor();
 
     if (exitVal != 0 && ) {
       ..println("Overwriting results");
       cmdLine = "cp " + outf.getPath() + " " + expf;
       executor = Runtime.getRuntime().exec(cmdLine);
       exitVal = executor.waitFor();
     }
 
     return exitVal;
   }
 
   public int checkParseResults(String tnameASTNode treethrows Exception {
 
     if (tree != null) {
       File parseDir = new File("parse");
       String expf = outPath(parseDir.toString(), tname.concat(".out"));
 
       File outf = null;
       outf = new File();
       outf = new File(outftname.concat(".out"));
 
       FileWriter outfd = new FileWriter(outf);
       outfd.write(tree.toStringTree());
       outfd.close();
 
       String cmdLine = "diff " + outf.getPath() + " " + expf;
       ..println(cmdLine);
 
       Process executor = Runtime.getRuntime().exec(cmdLine);
 
       StreamPrinter outPrinter = new StreamPrinter(
           executor.getInputStream(), null, SessionState.getConsole().getChildOutStream());
       StreamPrinter errPrinter = new StreamPrinter(
           executor.getErrorStream(), null, SessionState.getConsole().getChildErrStream());
 
       outPrinter.start();
       errPrinter.start();
 
       int exitVal = executor.waitFor();
 
       if (exitVal != 0 && ) {
         ..println("Overwriting results");
         cmdLine = "cp " + outf.getPath() + " " + expf;
         executor = Runtime.getRuntime().exec(cmdLine);
         exitVal = executor.waitFor();
       }
 
       return exitVal;
     } else {
       throw new Exception("Parse tree is null");
     }
   }
 
   public int checkPlan(String tnameList<Task<? extends Serializable>> tasksthrows Exception {
 
     if (tasks != null) {
       File planDir = new File("plan");
       String planFile = outPath(planDir.toString(), tname + ".xml");
 
       File outf = null;
       outf = new File();
       outf = new File(outftname.concat(".xml"));
 
       FileOutputStream ofs = new FileOutputStream(outf);
       for (Task<? extends Serializableplan : tasks) {
         Utilities.serializeTasks(planofs);
       }
 
       String[] cmdArray = new String[6];
       cmdArray[0] = "diff";
       cmdArray[1] = "-b";
       cmdArray[2] = "-I";
       cmdArray[3] = "\\(\\(<java version=\".*\" class=\"java.beans.XMLDecoder\">\\)"
           + "\\|\\(<string>.*/tmp/.*</string>\\)"
           + "\\|\\(<string>file:.*</string>\\)"
           + "\\|\\(<string>pfile:.*</string>\\)"
           + "\\|\\(<string>[0-9]\\{10\\}</string>\\)"
           + "\\|\\(<string>/.*/warehouse/.*</string>\\)\\)";
       cmdArray[4] = outf.getPath();
       cmdArray[5] = planFile;
       ..println(cmdArray[0] + " " + cmdArray[1] + " " + cmdArray[2]
           + "\'" + cmdArray[3] + "\'" + " " + cmdArray[4] + " " + cmdArray[5]);
 
       Process executor = Runtime.getRuntime().exec(cmdArray);
 
       StreamPrinter outPrinter = new StreamPrinter(
           executor.getInputStream(), null, SessionState.getConsole().getChildOutStream());
       StreamPrinter errPrinter = new StreamPrinter(
           executor.getErrorStream(), null, SessionState.getConsole().getChildErrStream());
 
       outPrinter.start();
       errPrinter.start();
 
       int exitVal = executor.waitFor();
 
       if (exitVal != 0 && ) {
         ..println("Overwriting results");
         String cmdLine = "cp " + outf.getPath() + " " + planFile;
         executor = Runtime.getRuntime().exec(cmdLine);
         exitVal = executor.waitFor();
       }
 
       return exitVal;
     } else {
       throw new Exception("Plan is null");
     }
 
   }
 
 
   /* This seems unused. Comment out first in case it is used somewhere.
   public int checkResults(String tname) throws Exception {
     Path warehousePath = new Path(FileSystem.get(conf).getUri().getPath());
     warehousePath = new Path(warehousePath, (new URI(testWarehouse)).getPath());
 
     Path localPath = new Path(FileSystem.getLocal(conf).getUri().getPath());
     localPath = new Path(localPath, logDir);
     localPath = new Path(localPath, "warehouse_local_copy");
     System.out.println("warehousePath = " + warehousePath.toString()
         + " localPath = " + localPath.toString());
 
     if (FileSystem.getLocal(conf).exists(localPath)) {
       FileSystem.getLocal(conf).delete(localPath, true);
     }
 
     copyDirectoryToLocal(warehousePath, localPath);
     normalizeNames(new File(localPath.toUri().getPath()));
 
     String[] cmdArray;
     if (overWrite == false) {
       cmdArray = new String[6];
       cmdArray[0] = "diff";
       cmdArray[1] = "-r";
       cmdArray[2] = "--exclude=tmp";
       cmdArray[3] = "--exclude=.svn";
       cmdArray[4] = localPath.toUri().getPath();
       cmdArray[5] = (new File(outDir, tname)).getPath() + "/warehouse";
       System.out.println(cmdArray[0] + " " + cmdArray[1] + " " + cmdArray[2]
           + " " + cmdArray[3] + " " + cmdArray[4] + " " + cmdArray[5]);
     } else {
       System.out.println("overwritting");
       // Remove any existing output
       String[] cmdArray1 = new String[5];
       cmdArray1[0] = "rm";
       cmdArray1[1] = "-rf";
       cmdArray1[2] = (new File(outDir, tname)).getPath();
       System.out
           .println(cmdArray1[0] + " " + cmdArray1[1] + " " + cmdArray1[2]);
 
       Process executor = Runtime.getRuntime().exec(cmdArray1);
 
       StreamPrinter outPrinter = new StreamPrinter(
           executor.getInputStream(), null, SessionState.getConsole().getChildOutStream());
       StreamPrinter errPrinter = new StreamPrinter(
           executor.getErrorStream(), null, SessionState.getConsole().getChildErrStream());
 
       outPrinter.start();
       errPrinter.start();
       int exitVal = executor.waitFor();
       if (exitVal != 0) {
         return exitVal;
       }
 
       // Capture code
       cmdArray = new String[5];
       cmdArray[0] = "cp";
       cmdArray[1] = "-r";
       cmdArray[2] = localPath.toUri().getPath();
       cmdArray[3] = (new File(outDir, tname)).getPath();
       System.out.println(cmdArray[0] + " " + cmdArray[1] + " " + cmdArray[2]
           + " " + cmdArray[3]);
     }
 
     Process executor = Runtime.getRuntime().exec(cmdArray);
 
     StreamPrinter outPrinter = new StreamPrinter(
         executor.getInputStream(), null, SessionState.getConsole().getChildOutStream());
     StreamPrinter errPrinter = new StreamPrinter(
         executor.getErrorStream(), null, SessionState.getConsole().getChildErrStream());
 
     outPrinter.start();
     errPrinter.start();
 
     int exitVal = executor.waitFor();
 
     return exitVal;
   }
   */

  
Given the current configurations (e.g., hadoop version and execution mode), return the correct file name to compare with the current test run output.

Parameters:
outDir The directory where the reference log files are stored.
testName The test file name (terminated by ".out").
Returns:
The file name appended with the configuration values if it exists.
 
   public String outPath(String outDirString testName) {
     String ret = (new File(outDirtestName)).getPath();
     // List of configurations. Currently the list consists of hadoop version and execution mode only
     List<Stringconfigs = new ArrayList<String>();
     configs.add(this.);
 
     Deque<Stringstack = new LinkedList<String>();
     StringBuilder sb = new StringBuilder();
     sb.append(testName);
     stack.push(sb.toString());
 
     // example file names are input1.q.out_0.20.0_minimr or input2.q.out_0.17
     for (String sconfigs) {
       sb.append('_');
       sb.append(s);
       stack.push(sb.toString());
     }
     while (stack.size() > 0) {
       String fileName = stack.pop();
       File f = new File(outDirfileName);
       if (f.exists()) {
         ret = f.getPath();
         break;
       }
     }
    return ret;
   }
 
   public int checkCliDriverResults(String tnamethrows Exception {
     String[] cmdArray;
     assert(.containsKey(tname));
 
     String outFileName = outPath(tname + ".out");
 
     cmdArray = new String[] {
         "diff""-a",
         "-I""file:",
         "-I""pfile:",
         "-I""hdfs:",
         "-I""/tmp/",
         "-I""invalidscheme:",
         "-I""lastUpdateTime",
         "-I""lastAccessTime",
         "-I""[Oo]wner",
         "-I""CreateTime",
         "-I""LastAccessTime",
         "-I""Location",
         "-I""transient_lastDdlTime",
         "-I""last_modified_",
         "-I""java.lang.RuntimeException",
         "-I""at org",
         "-I""at sun",
         "-I""at java",
         "-I""at junit",
         "-I""Caused by:",
         "-I""LOCK_QUERYID:",
         "-I""grantTime",
         "-I""[.][.][.] [0-9]* more",
         "-I""USING 'java -cp",
         (new File(tname + ".out")).getPath(),
         outFileName };
 
     ..println(org.apache.commons.lang.StringUtils.join(cmdArray' '));
 
     Process executor = Runtime.getRuntime().exec(cmdArray);
 
     StreamPrinter outPrinter = new StreamPrinter(
         executor.getInputStream(), null, SessionState.getConsole().getChildOutStream());
     StreamPrinter errPrinter = new StreamPrinter(
         executor.getErrorStream(), null, SessionState.getConsole().getChildErrStream());
 
     outPrinter.start();
     errPrinter.start();
 
     int exitVal = executor.waitFor();
 
     if (exitVal != 0 && ) {
       ..println("Overwriting results");
       cmdArray = new String[3];
       cmdArray[0] = "cp";
       cmdArray[1] = (new File(tname + ".out")).getPath();
       cmdArray[2] = outFileName;
       executor = Runtime.getRuntime().exec(cmdArray);
       exitVal = executor.waitFor();
     }
 
     return exitVal;
   }
 
   public ASTNode parseQuery(String tnamethrows Exception {
     return .parse(.get(tname));
   }
 
   public void resetParser() throws SemanticException {
     .init();
      = new ParseDriver();
      = new SemanticAnalyzer();
   }
 
 
   public List<Task<? extends Serializable>> analyzeAST(ASTNode astthrows Exception {
 
     // Do semantic analysis and plan generation
     Context ctx = new Context();
     while ((ast.getToken() == null) && (ast.getChildCount() > 0)) {
       ast = (ASTNodeast.getChild(0);
     }
 
     .analyze(astctx);
     ctx.clear();
     return .getRootTasks();
   }
 
   public TreeMap<StringStringgetQMap() {
     return ;
   }

  
QTestSetup defines test fixtures which are reused across testcases, and are needed before any test can be run
 
   public static class QTestSetup
   {
     private MiniZooKeeperCluster zooKeeperCluster = null;
     private int zkPort;
     private ZooKeeper zooKeeper;
 
     public QTestSetup() {
     }
 
    public void preTest(HiveConf confthrows Exception {
      if ( == null) {
        String tmpdir =  System.getProperty("user.dir")+"/../build/ql/tmp";
         = new MiniZooKeeperCluster();
         = .startup(new File(tmpdir"zookeeper"));
      }
      if ( != null) {
        .close();
      }
      int sessionTimeout = conf.getIntVar(..);
       = new ZooKeeper("localhost:" + sessionTimeoutnull);
      String zkServer = "localhost";
      conf.set("hive.zookeeper.quorum"zkServer);
      conf.set("hive.zookeeper.client.port""" + );
    }
    public void postTest(HiveConf confthrows Exception {
      if ( == null) {
        return;
      }
      if ( != null) {
        .close();
      }
      ZooKeeperHiveLockManager.releaseAllLocks(conf);
    }
    public void tearDown() throws Exception {
      if ( != null) {
        .shutdown();
         = null;
      }
    }
  }

  
QTRunner: Runnable class for running a a single query file.
  public static class QTRunner implements Runnable {
    private final QTestUtil qt;
    private final String fname;
    public QTRunner(QTestUtil qtString fname) {
      this. = qt;
      this. = fname;
    }
    public void run() {
      try {
        // assumption is that environment has already been cleaned once globally
        // hence each thread does not call cleanUp() and createSources() again
        .cliInit(false);
        .executeClient();
      } catch (Throwable e) {
        ..println("Query file " +  + " failed with exception "
            + e.getMessage());
        e.printStackTrace();
      }
    }
  }

  
executes a set of query files either in sequence or in parallel. Uses QTestUtil to do so

Parameters:
qfiles array of input query files containing arbitrary number of hive queries
resDirs array of output directories one corresponding to each input query file
mt whether to run in multithreaded mode or not
Returns:
true if all the query files were executed successfully, else false In multithreaded mode each query file is run in a separate thread. the caller has to arrange that different query files do not collide (in terms of destination tables)
  public static boolean queryListRunner(File[] qfilesString[] resDirs,
                                        String[] logDirsboolean mtTest test) {
    assert (qfiles.length == resDirs.length);
    assert (qfiles.length == logDirs.length);
    boolean failed = false;
    try {
      QTestUtil[] qt = new QTestUtil[qfiles.length];
      QTestSetup[] qsetup = new QTestSetup[qfiles.length];
      for (int i = 0; i < qfiles.lengthi++) {
        qt[i] = new QTestUtil(resDirs[i], logDirs[i], false"0.20");
        qt[i].addFile(qfiles[i]);
        qt[i].clearTestSideEffects();
      }
      if (mt) {
        // in multithreaded mode - do cleanup/initialization just once
        qt[0].cleanUp();
        qt[0].createSources();
        qt[0].clearTestSideEffects();
        QTRunner[] qtRunners = new QTestUtil.QTRunner[qfiles.length];
        Thread[] qtThread = new Thread[qfiles.length];
        for (int i = 0; i < qfiles.lengthi++) {
          qtRunners[i] = new QTestUtil.QTRunner(qt[i], qfiles[i].getName());
          qtThread[i] = new Thread(qtRunners[i]);
        }
        for (int i = 0; i < qfiles.lengthi++) {
          qtThread[i].start();
        }