TestSetFile.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:5k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.io;
  19. import java.io.*;
  20. import java.util.*;
  21. import junit.framework.TestCase;
  22. import org.apache.commons.logging.*;
  23. import org.apache.hadoop.fs.*;
  24. import org.apache.hadoop.conf.*;
  25. import org.apache.hadoop.io.SequenceFile.CompressionType;
  26. /** Support for flat files of binary key/value pairs. */
  27. public class TestSetFile extends TestCase {
  28.   private static final Log LOG = LogFactory.getLog(TestSetFile.class);
  29.   private static String FILE =
  30.     System.getProperty("test.build.data",".") + "/test.set";
  31.   private static Configuration conf = new Configuration();
  32.   
  33.   public TestSetFile(String name) { super(name); }
  34.   public void testSetFile() throws Exception {
  35.     FileSystem fs = FileSystem.getLocal(conf);
  36.     try {
  37.       RandomDatum[] data = generate(10000);
  38.       writeTest(fs, data, FILE, CompressionType.NONE);
  39.       readTest(fs, data, FILE);
  40.       writeTest(fs, data, FILE, CompressionType.BLOCK);
  41.       readTest(fs, data, FILE);
  42.     } finally {
  43.       fs.close();
  44.     }
  45.   }
  46.   private static RandomDatum[] generate(int count) {
  47.     LOG.info("generating " + count + " records in memory");
  48.     RandomDatum[] data = new RandomDatum[count];
  49.     RandomDatum.Generator generator = new RandomDatum.Generator();
  50.     for (int i = 0; i < count; i++) {
  51.       generator.next();
  52.       data[i] = generator.getValue();
  53.     }
  54.     LOG.info("sorting " + count + " records");
  55.     Arrays.sort(data);
  56.     return data;
  57.   }
  58.   private static void writeTest(FileSystem fs, RandomDatum[] data,
  59.                                 String file, CompressionType compress)
  60.     throws IOException {
  61.     MapFile.delete(fs, file);
  62.     LOG.info("creating with " + data.length + " records");
  63.     SetFile.Writer writer =
  64.       new SetFile.Writer(conf, fs, file,
  65.                          WritableComparator.get(RandomDatum.class),
  66.                          compress);
  67.     for (int i = 0; i < data.length; i++)
  68.       writer.append(data[i]);
  69.     writer.close();
  70.   }
  71.   private static void readTest(FileSystem fs, RandomDatum[] data, String file)
  72.     throws IOException {
  73.     RandomDatum v = new RandomDatum();
  74.     int sample = (int)Math.sqrt(data.length);
  75.     Random random = new Random();
  76.     LOG.info("reading " + sample + " records");
  77.     SetFile.Reader reader = new SetFile.Reader(fs, file, conf);
  78.     for (int i = 0; i < sample; i++) {
  79.       if (!reader.seek(data[random.nextInt(data.length)]))
  80.         throw new RuntimeException("wrong value at " + i);
  81.     }
  82.     reader.close();
  83.     LOG.info("done reading " + data.length);
  84.   }
  85.   /** For debugging and testing. */
  86.   public static void main(String[] args) throws Exception {
  87.     int count = 1024 * 1024;
  88.     boolean create = true;
  89.     boolean check = true;
  90.     String file = FILE;
  91.     String compress = "NONE";
  92.     String usage = "Usage: TestSetFile [-count N] [-nocreate] [-nocheck] [-compress type] file";
  93.       
  94.     if (args.length == 0) {
  95.       System.err.println(usage);
  96.       System.exit(-1);
  97.     }
  98.       
  99.     int i = 0;
  100.     Path fpath=null;
  101.     FileSystem fs = null;    
  102.     try {
  103.       for (; i < args.length; i++) {       // parse command line
  104.         if (args[i] == null) {
  105.           continue;
  106.         } else if (args[i].equals("-count")) {
  107.           count = Integer.parseInt(args[++i]);
  108.         } else if (args[i].equals("-nocreate")) {
  109.           create = false;
  110.         } else if (args[i].equals("-nocheck")) {
  111.           check = false;
  112.         } else if (args[i].equals("-compress")) {
  113.           compress = args[++i];
  114.         } else {
  115.           // file is required parameter
  116.           file = args[i];
  117.           fpath=new Path(file);
  118.         }
  119.       }
  120.       
  121.       fs = fpath.getFileSystem(conf);
  122.       
  123.       LOG.info("count = " + count);
  124.       LOG.info("create = " + create);
  125.       LOG.info("check = " + check);
  126.       LOG.info("compress = " + compress);
  127.       LOG.info("file = " + file);
  128.       
  129.       RandomDatum[] data = generate(count);
  130.       
  131.       if (create) {
  132.         writeTest(fs, data, file, CompressionType.valueOf(compress));
  133.       }
  134.       
  135.       if (check) {
  136.         readTest(fs, data, file);
  137.       }
  138.   
  139.     } finally {
  140.       fs.close();
  141.     }
  142.   }
  143. }