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

网格计算

开发平台:

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 junit.framework.TestCase;
  20. import java.nio.ByteBuffer;
  21. import java.nio.charset.CharacterCodingException;
  22. import java.util.Random;
  23. /** Unit tests for LargeUTF8. */
  24. public class TestText extends TestCase {
  25.   private static final int NUM_ITERATIONS = 100;
  26.   public TestText(String name) { super(name); }
  27.   private static final Random RANDOM = new Random(1);
  28.   private static final int RAND_LEN = -1;
  29.   
  30.   // generate a valid java String
  31.   private static String getTestString(int len) throws Exception {
  32.     StringBuffer buffer = new StringBuffer();    
  33.     int length = (len==RAND_LEN) ? RANDOM.nextInt(1000) : len;
  34.     while (buffer.length()<length) {
  35.       int codePoint = RANDOM.nextInt(Character.MAX_CODE_POINT);
  36.       char tmpStr[] = new char[2];
  37.       if (Character.isDefined(codePoint)) {
  38.         //unpaired surrogate
  39.         if (codePoint < Character.MIN_SUPPLEMENTARY_CODE_POINT &&
  40.             !Character.isHighSurrogate((char)codePoint) &&
  41.             !Character.isLowSurrogate((char)codePoint)) {
  42.           Character.toChars(codePoint, tmpStr, 0);
  43.           buffer.append(tmpStr);
  44.         }
  45.       }
  46.     }
  47.     return buffer.toString();
  48.   }
  49.   
  50.   public static String getTestString() throws Exception {
  51.     return getTestString(RAND_LEN);
  52.   }
  53.   
  54.   public static String getLongString() throws Exception {
  55.     String str = getTestString();
  56.     int length = Short.MAX_VALUE+str.length();
  57.     StringBuffer buffer = new StringBuffer();
  58.     while(buffer.length()<length)
  59.       buffer.append(str);
  60.       
  61.     return buffer.toString();
  62.   }
  63.   public void testWritable() throws Exception {
  64.     for (int i = 0; i < NUM_ITERATIONS; i++) {
  65.       String str;
  66.       if (i == 0)
  67.         str = getLongString();
  68.       else
  69.         str = getTestString();
  70.       TestWritable.testWritable(new Text(str));
  71.     }
  72.   }
  73.   public void testCoding() throws Exception {
  74.     String before = "Bad t encoding t testcase";
  75.     Text text = new Text(before);
  76.     String after = text.toString();
  77.     assertTrue(before.equals(after));
  78.     for (int i = 0; i < NUM_ITERATIONS; i++) {
  79.       // generate a random string
  80.       if (i == 0)
  81.         before = getLongString();
  82.       else
  83.         before = getTestString();
  84.     
  85.       // test string to utf8
  86.       ByteBuffer bb = Text.encode(before);
  87.           
  88.       byte[] utf8Text = bb.array();
  89.       byte[] utf8Java = before.getBytes("UTF-8");
  90.       assertEquals(0, WritableComparator.compareBytes(
  91.                                                       utf8Text, 0, bb.limit(),
  92.                                                       utf8Java, 0, utf8Java.length));
  93.               
  94.       // test utf8 to string
  95.       after = Text.decode(utf8Java);
  96.       assertTrue(before.equals(after));
  97.     }
  98.   }
  99.   
  100.   
  101.   public void testIO() throws Exception {
  102.     DataOutputBuffer out = new DataOutputBuffer();
  103.     DataInputBuffer in = new DataInputBuffer();
  104.     for (int i = 0; i < NUM_ITERATIONS; i++) {
  105.       // generate a random string
  106.       String before;          
  107.       if (i == 0)
  108.         before = getLongString();
  109.       else
  110.         before = getTestString();
  111.         
  112.       // write it
  113.       out.reset();
  114.       Text.writeString(out, before);
  115.         
  116.       // test that it reads correctly
  117.       in.reset(out.getData(), out.getLength());
  118.       String after = Text.readString(in);
  119.       assertTrue(before.equals(after));
  120.         
  121.       // Test compatibility with Java's other decoder 
  122.       int strLenSize = WritableUtils.getVIntSize(Text.utf8Length(before));
  123.       String after2 = new String(out.getData(), strLenSize, 
  124.                                  out.getLength()-strLenSize, "UTF-8");
  125.       assertTrue(before.equals(after2));
  126.     }
  127.   }
  128.   public void testCompare() throws Exception {
  129.     DataOutputBuffer out1 = new DataOutputBuffer();
  130.     DataOutputBuffer out2 = new DataOutputBuffer();
  131.     DataOutputBuffer out3 = new DataOutputBuffer();
  132.     Text.Comparator comparator = new Text.Comparator();
  133.     for (int i=0; i<NUM_ITERATIONS; i++) {
  134.       // reset output buffer
  135.       out1.reset();
  136.       out2.reset();
  137.       out3.reset();
  138.       // generate two random strings
  139.       String str1 = getTestString();
  140.       String str2 = getTestString();
  141.       if (i == 0) {
  142.         str1 = getLongString();
  143.         str2 = getLongString();
  144.       } else {
  145.         str1 = getTestString();
  146.         str2 = getTestString();
  147.       }
  148.           
  149.       // convert to texts
  150.       Text txt1 = new Text(str1);
  151.       Text txt2 = new Text(str2);
  152.       Text txt3 = new Text(str1);
  153.           
  154.       // serialize them
  155.       txt1.write(out1);
  156.       txt2.write(out2);
  157.       txt3.write(out3);
  158.           
  159.       // compare two strings by looking at their binary formats
  160.       int ret1 = comparator.compare(out1.getData(), 0, out1.getLength(),
  161.                                     out2.getData(), 0, out2.getLength());
  162.       // compare two strings
  163.       int ret2 = txt1.compareTo(txt2);
  164.           
  165.       assertEquals(ret1, ret2);
  166.           
  167.       // test equal
  168.       assertEquals(txt1.compareTo(txt3), 0);
  169.       assertEquals(comparator.compare(out1.getData(), 0, out3.getLength(),
  170.                                       out3.getData(), 0, out3.getLength()), 0);
  171.     }
  172.   }
  173.       
  174.   public void testFind() throws Exception {
  175.     Text text = new Text("abcdu20acbdcdu20ac");
  176.     assertTrue(text.find("abd")==-1);
  177.     assertTrue(text.find("ac")==-1);
  178.     assertTrue(text.find("u20ac")==4);
  179.     assertTrue(text.find("u20ac", 5)==11);
  180.   }
  181.   public void testFindAfterUpdatingContents() throws Exception {
  182.     Text text = new Text("abcd");
  183.     text.set("a".getBytes());
  184.     assertEquals(text.getLength(),1);
  185.     assertEquals(text.find("a"), 0);
  186.     assertEquals(text.find("b"), -1);
  187.   }
  188.   public void testValidate() throws Exception {
  189.     Text text = new Text("abcdu20acbdcdu20ac");
  190.     byte [] utf8 = text.getBytes();
  191.     int length = text.getLength();
  192.     Text.validateUTF8(utf8, 0, length);
  193.   }
  194.   public void testTextText() throws CharacterCodingException {
  195.     Text a=new Text("abc");
  196.     Text b=new Text("a");
  197.     b.set(a);
  198.     assertEquals("abc", b.toString());
  199.     a.append("xdefgxxx".getBytes(), 1, 4);
  200.     assertEquals("modified aliased string", "abc", b.toString());
  201.     assertEquals("appended string incorrectly", "abcdefg", a.toString());
  202.   }
  203.   
  204.   private class ConcurrentEncodeDecodeThread extends Thread {
  205.     public ConcurrentEncodeDecodeThread(String name) {
  206.       super(name);
  207.     }
  208.     public void run() {
  209.       String name = this.getName();
  210.       DataOutputBuffer out = new DataOutputBuffer();
  211.       DataInputBuffer in = new DataInputBuffer();
  212.       for (int i=0; i < 1000; ++i) {
  213.         try {
  214.           out.reset();
  215.           WritableUtils.writeString(out, name);
  216.           
  217.           in.reset(out.getData(), out.getLength());
  218.           String s = WritableUtils.readString(in);
  219.           
  220.           assertEquals(name, s);
  221.         } catch (Exception ioe) {
  222.           throw new RuntimeException(ioe);
  223.         }
  224.       }
  225.     }
  226.   }
  227.   
  228.   public void testConcurrentEncodeDecode() throws Exception{
  229.     Thread thread1 = new ConcurrentEncodeDecodeThread("apache");
  230.     Thread thread2 = new ConcurrentEncodeDecodeThread("hadoop");
  231.     
  232.     thread1.start();
  233.     thread2.start();
  234.     
  235.     thread2.join();
  236.     thread2.join();
  237.   }
  238.   public static void main(String[] args)  throws Exception
  239.   {
  240.     TestText test = new TestText("main");
  241.     test.testIO();
  242.     test.testCompare();
  243.     test.testCoding();
  244.     test.testWritable();
  245.     test.testFind();
  246.     test.testValidate();
  247.   }
  248. }