source: sample/hadoop-0.17/tw/org/nchc/tuple/ArrayListWritableComparableTest.java @ 65

/*
 * Cloud9: A MapReduce Library for Hadoop
 * 
 * Licensed 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 tw.org.nchc.tuple;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.ArrayList;

import junit.framework.*;

import org.apache.hadoop.io.FloatWritable;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;
import org.junit.Test;

public class ArrayListWritableComparableTest {

  @Test
  public void testBasic() throws IOException {
    ArrayListWritableComparable<Text> list = new ArrayListWritableComparable<Text>();

    list.add(new Text("hi"));
    list.add(new Text("there"));

    assertEquals(list.get(0).toString(), "hi");
    assertEquals(list.get(1).toString(), "there");
  }

  @Test
  public void testSerialize1() throws IOException {
    //ArrayListWritableComparable<Text> list = new ArrayListWritableComparable<Text>();
    ArrayListWritableComparable<WritableComparable> list = new ArrayListWritableComparable<WritableComparable>();
    list.add(new Text("hi"));
    list.add(new Text("there"));

    ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
    DataOutputStream dataOut = new DataOutputStream(bytesOut);

    list.write(dataOut);

    ArrayListWritableComparable<Text> newList = new ArrayListWritableComparable<Text>();
    newList.readFields(new DataInputStream(new ByteArrayInputStream(
        bytesOut.toByteArray())));

    assertEquals(newList.get(0).toString(), "hi");
    assertEquals(newList.get(1).toString(), "there");
  }

  @Test
  public void testSerialize2() throws IOException {
    ArrayListWritableComparable<FloatWritable> list = new ArrayListWritableComparable<FloatWritable>();

    list.add(new FloatWritable(0.3f));
    list.add(new FloatWritable(3244.2f));

    ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
    DataOutputStream dataOut = new DataOutputStream(bytesOut);

    list.write(dataOut);

    ArrayListWritableComparable<FloatWritable> newList = new ArrayListWritableComparable<FloatWritable>();
    newList.readFields(new DataInputStream(new ByteArrayInputStream(
        bytesOut.toByteArray())));

    assertTrue(newList.get(0).get() == 0.3f);
    assertTrue(newList.get(1).get() == 3244.2f);
  }

  @Test
  public void testToString() {
    ArrayListWritableComparable<Text> list = new ArrayListWritableComparable<Text>();

    list.add(new Text("hi"));
    list.add(new Text("there"));

    assertEquals(list.toString(), "[hi, there]");
  }

  @Test
  public void testClear() {
    ArrayListWritableComparable<Text> list = new ArrayListWritableComparable<Text>();

    list.add(new Text("hi"));
    list.add(new Text("there"));
    list.clear();
    
    assertEquals(list.size(), 0);
  }

  @Test
  public void testEmpty() throws IOException {
    ArrayListWritableComparable<Text> list = new ArrayListWritableComparable<Text>();
    
    assertTrue(list.size() == 0);
    
    ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
    DataOutputStream dataOut = new DataOutputStream(bytesOut);

    list.write(dataOut);

    ArrayListWritableComparable<Text> newList = new ArrayListWritableComparable<Text>();
    newList.readFields(new DataInputStream(new ByteArrayInputStream(
        bytesOut.toByteArray())));
    assertTrue(newList.size() == 0);
    
    newList.add(new Text("Hey"));
    assertEquals(newList.get(0),new Text("Hey"));

  }
  
  /*@Test
  public void testTypeSafety() {
    ArrayListWritableComparable<WritableComparable> list = new ArrayListWritableComparable<WritableComparable> ();
    list.add(new Text("Hello"));
    list.add(new Text("Are you there"));
    
    try {
      list.add(new IntWritable(5));
      assertTrue(false); // should throw an exception before reaching this line.
    } catch (IllegalArgumentException e) {
      assertTrue(true);
    }
    
    ArrayList<WritableComparable> otherList = new ArrayList<WritableComparable>();
    otherList.add(new Text("Test"));
    otherList.add(new Text("Test 2"));
    
    assertTrue(list.addAll(otherList));
    
    otherList.add(new IntWritable(6));
    try {
      list.addAll(otherList);
      assertTrue(false);
    } catch (IllegalArgumentException e) {
      assertTrue(true);
    }
  }*/
  
  @Test 
  public void testListMethods() {
    IntWritable a = new IntWritable(1);
    IntWritable b = new IntWritable(2);
    IntWritable c = new IntWritable(3);
    IntWritable d = new IntWritable(4);
    IntWritable e = new IntWritable(5);
    
    ArrayListWritableComparable<IntWritable> list = new ArrayListWritableComparable<IntWritable>();
    assertTrue(list.isEmpty());
    list.add(a);
    list.add(b);
    list.add(c);
    list.add(d);
    list.add(e);
    
    int pos = 0;
    for (IntWritable i : list) {
      assertEquals(i, list.get(pos));
      ++pos;
    }
    
    assertTrue(list.indexOf(d) == 3);
    list.add(2, a);
    assertTrue(list.lastIndexOf(a) == 2);
    assertEquals(list.get(2), list.get(0));
    assertTrue(list.size() == 6);
    
    assertTrue(list.contains(c));
    assertTrue(!list.contains(new IntWritable(123)));
    
    ArrayList<IntWritable> otherList = new ArrayList<IntWritable>();
    otherList.add(a);
    otherList.add(b);
    otherList.add(c);
    
    assertTrue(list.containsAll(otherList));
    
    otherList.add(new IntWritable(200));
    assertTrue(!list.containsAll(otherList));
    
    assertEquals(a, otherList.remove(0));
    assertTrue(list.remove(d));
    
  }
  
  @Test
  public void testSorting1() {
    ArrayListWritableComparable<Text> list1 = new ArrayListWritableComparable<Text>();
    ArrayListWritableComparable<Text> list2 = new ArrayListWritableComparable<Text>();

    list1.add(new Text("a"));

    assertTrue(list1.compareTo(list2) > 0);
  }
  
  @Test
  public void testSorting2() {
    ArrayListWritableComparable<Text> list1 = new ArrayListWritableComparable<Text>();
    ArrayListWritableComparable<Text> list2 = new ArrayListWritableComparable<Text>();

    list1.add(new Text("a"));
    list2.add(new Text("b"));

    assertTrue(list1.compareTo(list2) < 0);
    assertTrue(list2.compareTo(list1) > 0);
    
    list2.clear();
    list2.add(new Text("a"));
    
    assertTrue(list1.compareTo(list2) == 0);
    
    list1.add(new Text("a"));
    list2.add(new Text("b"));
    
    // list 1 is now [a, a]
    // list 2 is now [a, b]
    assertTrue(list1.compareTo(list2) < 0);
    assertTrue(list2.compareTo(list1) > 0);

    // list 1 is now [a, a, a]
    list1.add(new Text("a"));
    
    assertTrue(list1.compareTo(list2) < 0);
  }

  @Test
  public void testSorting3() {
    ArrayListWritableComparable<Text> list1 = new ArrayListWritableComparable<Text>();
    ArrayListWritableComparable<Text> list2 = new ArrayListWritableComparable<Text>();
    ArrayListWritableComparable<Text> list3 = new ArrayListWritableComparable<Text>();

    list1.add(new Text("a"));
    
    list2.add(new Text("a"));
    list2.add(new Text("a"));
    
    list3.add(new Text("a"));
    list3.add(new Text("a"));
    
    assertTrue(list2.compareTo(list3) == 0);

    list3.add(new Text("a"));
    
    // list 1 is [a]
    // list 2 is [a, a]
    // list 3 is [a, a, a]
    
    assertTrue(list1.compareTo(list2) < 0);
    assertTrue(list1.compareTo(list3) < 0);
    assertTrue(list2.compareTo(list1) > 0);
    assertTrue(list2.compareTo(list3) < 0);
    assertTrue(list3.compareTo(list1) > 0);
    assertTrue(list3.compareTo(list2) > 0);
  }

  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(ArrayListWritableComparableTest.class);
  }

}