TestGenericWritable.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.io;
  19. import java.io.DataInput;
  20. import java.io.DataOutput;
  21. import java.io.IOException;
  22. import junit.framework.TestCase;
  23. import org.apache.hadoop.conf.Configurable;
  24. import org.apache.hadoop.conf.Configuration;
  25. /**
  26.  * TestCase for {@link GenericWritable} class.
  27.  * @see TestWritable#testWritable(Writable)
  28.  */
  29. public class TestGenericWritable extends TestCase {
  30.   private Configuration conf;
  31.   public static final String CONF_TEST_KEY = "test.generic.writable";
  32.   public static final String CONF_TEST_VALUE = "dummy";
  33.   @Override
  34.   protected void setUp() throws Exception {
  35.     super.setUp();
  36.     conf = new Configuration();
  37.     //set the configuration parameter
  38.     conf.set(CONF_TEST_KEY, CONF_TEST_VALUE);
  39.   }
  40.   /** Dummy class for testing {@link GenericWritable} */
  41.   public static class Foo implements Writable {
  42.     private String foo = "foo";
  43.     public void readFields(DataInput in) throws IOException {
  44.       foo = Text.readString(in);
  45.     }
  46.     public void write(DataOutput out) throws IOException {
  47.       Text.writeString(out, foo);
  48.     }
  49.     @Override
  50.     public boolean equals(Object obj) {
  51.       if (!(obj instanceof Foo))
  52.         return false;
  53.       return this.foo.equals(((Foo)obj).foo);
  54.     }
  55.   }
  56.   /** Dummy class for testing {@link GenericWritable} */
  57.   public static class Bar implements Writable, Configurable {
  58.     private int bar = 42; //The Answer to The Ultimate Question Of Life, the Universe and Everything
  59.     private Configuration conf = null;
  60.     public void readFields(DataInput in) throws IOException {
  61.       bar = in.readInt();
  62.     }
  63.     public void write(DataOutput out) throws IOException {
  64.       out.writeInt(bar);
  65.     }
  66.     public Configuration getConf() {
  67.       return conf;
  68.     }
  69.     public void setConf(Configuration conf) {
  70.       this.conf = conf;
  71.     }
  72.     @Override
  73.     public boolean equals(Object obj) {
  74.       if (!(obj instanceof Bar))
  75.         return false;
  76.       return this.bar == ((Bar)obj).bar;
  77.     }
  78.   }
  79.   /** Dummy class for testing {@link GenericWritable} */
  80.   public static class Baz extends Bar {
  81.     @Override
  82.     public void readFields(DataInput in) throws IOException {
  83.       super.readFields(in);
  84.       //needs a configuration parameter
  85.       assertEquals("Configuration is not set for the wrapped object", 
  86.           CONF_TEST_VALUE, getConf().get(CONF_TEST_KEY)); 
  87.     }
  88.     @Override
  89.     public void write(DataOutput out) throws IOException {
  90.       super.write(out);
  91.     }
  92.   }
  93.   /** Dummy class for testing {@link GenericWritable} */ 
  94.   public static class FooGenericWritable extends GenericWritable {
  95.     @Override
  96.     @SuppressWarnings("unchecked")
  97.     protected Class<? extends Writable>[] getTypes() {
  98.       return new Class[] {Foo.class, Bar.class, Baz.class};
  99.     }
  100.     @Override
  101.     public boolean equals(Object obj) {
  102.       if(! (obj instanceof FooGenericWritable))
  103.         return false;
  104.       return get().equals(((FooGenericWritable)obj).get());
  105.     }
  106.   }
  107.   public void testFooWritable() throws Exception {
  108.     System.out.println("Testing Writable wrapped in GenericWritable");
  109.     FooGenericWritable generic = new FooGenericWritable();
  110.     generic.setConf(conf);
  111.     Foo foo = new Foo();
  112.     generic.set(foo);
  113.     TestWritable.testWritable(generic);
  114.   }
  115.   public void testBarWritable() throws Exception {
  116.     System.out.println("Testing Writable, Configurable wrapped in GenericWritable");
  117.     FooGenericWritable generic = new FooGenericWritable();
  118.     generic.setConf(conf);
  119.     Bar bar = new Bar();
  120.     bar.setConf(conf);
  121.     generic.set(bar);
  122.     //test writing generic writable
  123.     FooGenericWritable after 
  124.     = (FooGenericWritable)TestWritable.testWritable(generic, conf);
  125.     //test configuration
  126.     System.out.println("Testing if Configuration is passed to wrapped classes");
  127.     assertTrue(after.get() instanceof Configurable);
  128.     assertNotNull(((Configurable)after.get()).getConf());
  129.   }
  130.   public void testBazWritable() throws Exception {
  131.     System.out.println("Testing for GenericWritable to find class names");
  132.     FooGenericWritable generic = new FooGenericWritable();
  133.     generic.setConf(conf);
  134.     Baz baz = new Baz();
  135.     generic.set(baz);
  136.     TestWritable.testWritable(generic, conf);
  137.   }
  138.   public void testSet() throws Exception {
  139.     Foo foo = new Foo();
  140.     FooGenericWritable generic = new FooGenericWritable();
  141.     //exception should not occur
  142.     generic.set(foo);
  143.     try {
  144.       //exception should occur, since IntWritable is not registered
  145.       generic = new FooGenericWritable();
  146.       generic.set(new IntWritable(1));
  147.       fail("Generic writable should have thrown an exception for a Writable not registered");
  148.     }catch (RuntimeException e) {
  149.       //ignore
  150.     }
  151.   }
  152.   public void testGet() throws Exception {
  153.     Foo foo = new Foo();
  154.     FooGenericWritable generic = new FooGenericWritable();
  155.     generic.set(foo);
  156.     assertEquals(foo, generic.get());
  157.   }
  158. }