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

网格计算

开发平台:

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.mapred.join;
  19. import java.io.ByteArrayInputStream;
  20. import java.io.ByteArrayOutputStream;
  21. import java.io.DataInputStream;
  22. import java.io.DataOutputStream;
  23. import java.util.Arrays;
  24. import java.util.Random;
  25. import junit.framework.TestCase;
  26. import org.apache.hadoop.io.BooleanWritable;
  27. import org.apache.hadoop.io.BytesWritable;
  28. import org.apache.hadoop.io.FloatWritable;
  29. import org.apache.hadoop.io.IntWritable;
  30. import org.apache.hadoop.io.LongWritable;
  31. import org.apache.hadoop.io.Text;
  32. import org.apache.hadoop.io.Writable;
  33. public class TestTupleWritable extends TestCase {
  34.   private TupleWritable makeTuple(Writable[] writs) {
  35.     Writable[] sub1 = { writs[1], writs[2] };
  36.     Writable[] sub3 = { writs[4], writs[5] };
  37.     Writable[] sub2 = { writs[3], new TupleWritable(sub3), writs[6] };
  38.     Writable[] vals = { writs[0], new TupleWritable(sub1),
  39.                         new TupleWritable(sub2), writs[7], writs[8],
  40.                         writs[9] };
  41.     // [v0, [v1, v2], [v3, [v4, v5], v6], v7, v8, v9]
  42.     TupleWritable ret = new TupleWritable(vals);
  43.     for (int i = 0; i < 6; ++i) {
  44.       ret.setWritten(i);
  45.     }
  46.     ((TupleWritable)sub2[1]).setWritten(0);
  47.     ((TupleWritable)sub2[1]).setWritten(1);
  48.     ((TupleWritable)vals[1]).setWritten(0);
  49.     ((TupleWritable)vals[1]).setWritten(1);
  50.     for (int i = 0; i < 3; ++i) {
  51.       ((TupleWritable)vals[2]).setWritten(i);
  52.     }
  53.     return ret;
  54.   }
  55.   private int verifIter(Writable[] writs, TupleWritable t, int i) {
  56.     for (Writable w : t) {
  57.       if (w instanceof TupleWritable) {
  58.         i = verifIter(writs, ((TupleWritable)w), i);
  59.         continue;
  60.       }
  61.       assertTrue("Bad value", w.equals(writs[i++]));
  62.     }
  63.     return i;
  64.   }
  65.   public void testIterable() throws Exception {
  66.     Random r = new Random();
  67.     Writable[] writs = {
  68.       new BooleanWritable(r.nextBoolean()),
  69.       new FloatWritable(r.nextFloat()),
  70.       new FloatWritable(r.nextFloat()),
  71.       new IntWritable(r.nextInt()),
  72.       new LongWritable(r.nextLong()),
  73.       new BytesWritable("dingo".getBytes()),
  74.       new LongWritable(r.nextLong()),
  75.       new IntWritable(r.nextInt()),
  76.       new BytesWritable("yak".getBytes()),
  77.       new IntWritable(r.nextInt())
  78.     };
  79.     TupleWritable t = new TupleWritable(writs);
  80.     for (int i = 0; i < 6; ++i) {
  81.       t.setWritten(i);
  82.     }
  83.     verifIter(writs, t, 0);
  84.   }
  85.   public void testNestedIterable() throws Exception {
  86.     Random r = new Random();
  87.     Writable[] writs = {
  88.       new BooleanWritable(r.nextBoolean()),
  89.       new FloatWritable(r.nextFloat()),
  90.       new FloatWritable(r.nextFloat()),
  91.       new IntWritable(r.nextInt()),
  92.       new LongWritable(r.nextLong()),
  93.       new BytesWritable("dingo".getBytes()),
  94.       new LongWritable(r.nextLong()),
  95.       new IntWritable(r.nextInt()),
  96.       new BytesWritable("yak".getBytes()),
  97.       new IntWritable(r.nextInt())
  98.     };
  99.     TupleWritable sTuple = makeTuple(writs);
  100.     assertTrue("Bad count", writs.length == verifIter(writs, sTuple, 0));
  101.   }
  102.   public void testWritable() throws Exception {
  103.     Random r = new Random();
  104.     Writable[] writs = {
  105.       new BooleanWritable(r.nextBoolean()),
  106.       new FloatWritable(r.nextFloat()),
  107.       new FloatWritable(r.nextFloat()),
  108.       new IntWritable(r.nextInt()),
  109.       new LongWritable(r.nextLong()),
  110.       new BytesWritable("dingo".getBytes()),
  111.       new LongWritable(r.nextLong()),
  112.       new IntWritable(r.nextInt()),
  113.       new BytesWritable("yak".getBytes()),
  114.       new IntWritable(r.nextInt())
  115.     };
  116.     TupleWritable sTuple = makeTuple(writs);
  117.     ByteArrayOutputStream out = new ByteArrayOutputStream();
  118.     sTuple.write(new DataOutputStream(out));
  119.     ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
  120.     TupleWritable dTuple = new TupleWritable();
  121.     dTuple.readFields(new DataInputStream(in));
  122.     assertTrue("Failed to write/read tuple", sTuple.equals(dTuple));
  123.   }
  124.   public void testWideTuple() throws Exception {
  125.     Text emptyText = new Text("Should be empty");
  126.     Writable[] values = new Writable[64];
  127.     Arrays.fill(values,emptyText);
  128.     values[42] = new Text("Number 42");
  129.                                      
  130.     TupleWritable tuple = new TupleWritable(values);
  131.     tuple.setWritten(42);
  132.     
  133.     for (int pos=0; pos<tuple.size();pos++) {
  134.       boolean has = tuple.has(pos);
  135.       if (pos == 42) {
  136.         assertTrue(has);
  137.       }
  138.       else {
  139.         assertFalse("Tuple position is incorrectly labelled as set: " + pos, has);
  140.       }
  141.     }
  142.   }
  143.   
  144.   public void testWideTuple2() throws Exception {
  145.     Text emptyText = new Text("Should be empty");
  146.     Writable[] values = new Writable[64];
  147.     Arrays.fill(values,emptyText);
  148.     values[9] = new Text("Number 9");
  149.                                      
  150.     TupleWritable tuple = new TupleWritable(values);
  151.     tuple.setWritten(9);
  152.     
  153.     for (int pos=0; pos<tuple.size();pos++) {
  154.       boolean has = tuple.has(pos);
  155.       if (pos == 9) {
  156.         assertTrue(has);
  157.       }
  158.       else {
  159.         assertFalse("Tuple position is incorrectly labelled as set: " + pos, has);
  160.       }
  161.     }
  162.   }
  163. }