source: sample/hadoop-0.16/tw/org/nchc/tuple/TupleTest.java @ 229

/*
 * 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.assertFalse;
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 junit.framework.JUnit4TestAdapter;

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

public class TupleTest {

  public static final Schema SCHEMA1 = new Schema();
  static {
    SCHEMA1.addField("field0", String.class, "default");
    SCHEMA1.addField("field1", Boolean.class, true);
    SCHEMA1.addField("field2", Integer.class, new Integer(1));
    SCHEMA1.addField("field3", Long.class, new Long(2));
    SCHEMA1.addField("field4", Float.class, new Float(2.5));
    SCHEMA1.addField("field5", Double.class, new Double(3.14));
    SCHEMA1.addField("field6", String.class, "test");
  }

  // next few cases tests invalid field names: should throw exceptions
  @Test(expected = TupleException.class)
  public void testAccessNonExistentField1() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.get("FIELD");
  }

  @Test(expected = TupleException.class)
  public void testAccessNonExistentField2() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.getSymbol("FIELD");
  }

  @Test(expected = TupleException.class)
  public void testAccessNonExistentField3() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.set("Field0", "test");
  }

  @Test(expected = TupleException.class)
  public void testAccessNonExistentField4() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.setSymbol("Field0", "test");
  }

  @Test(expected = TupleException.class)
  public void testAccessNonExistentField5() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.containsSymbol("Field0");
  }

  @Test(expected = TupleException.class)
  public void testAccessNonExistentField6() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.getFieldType("Field0");
  }

  // can't set fields to null
  @Test(expected = TupleException.class)
  public void testSetNull1() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.set(0, null);
  }

  // can't set symbol as null
  @Test(expected = TupleException.class)
  public void testSetNull2() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.setSymbol(0, null);
  }

  // mismatch in field type
  @Test(expected = TupleException.class)
  public void testSetWrongType() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.set(0, 1);
  }

  @Test
  public void testHashCode() {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.setSymbol(0, "*");
    int hash1 = tuple.hashCode();

    tuple.set(0, "sample");
    int hash2 = tuple.hashCode();

    assertTrue(hash1 != hash2);
  }
  
  @Test
  public void testSorting() {
    
    Tuple tuple1 = SCHEMA1.instantiate();
    Tuple tuple2 = SCHEMA1.instantiate();
    
    assertEquals(tuple1.compareTo(tuple2), 0);
    
    tuple1.set("field0", "a");
    tuple1.set("field0", "b");
    
    assertTrue(tuple1.compareTo(tuple2) < 0);
    assertTrue(tuple2.compareTo(tuple1) > 0);
    
    tuple1.set("field1", true);
    tuple1.set("field1", false);
    
    assertTrue(tuple1.compareTo(tuple2) < 0);
    assertTrue(tuple2.compareTo(tuple1) > 0);
    
    tuple1.set("field2", 1);
    tuple1.set("field2", 2);
    
    assertTrue(tuple1.compareTo(tuple2) < 0);
    assertTrue(tuple2.compareTo(tuple1) > 0);
    
    tuple1.set("field3", 1L);
    tuple1.set("field3", 2L);
    
    assertTrue(tuple1.compareTo(tuple2) < 0);
    assertTrue(tuple2.compareTo(tuple1) > 0);

    tuple1.set("field4", 1.0f);
    tuple1.set("field4", 2.0f);
    
    assertTrue(tuple1.compareTo(tuple2) < 0);
    assertTrue(tuple2.compareTo(tuple1) > 0);

    tuple1.set("field5", 1.0d);
    tuple1.set("field5", 2.0d);
    
    assertTrue(tuple1.compareTo(tuple2) < 0);
    assertTrue(tuple2.compareTo(tuple1) > 0);
  }

  // tests unpacking of default values
  @Test
  public void testSerializeDefaultValues() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

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

    tuple.write(dataOut);

    Tuple t = Tuple.createFrom(new DataInputStream(
        new ByteArrayInputStream(bytesOut.toByteArray())));

    assertEquals(t.get(0), "default");
    assertEquals(t.get(1), true);
    assertEquals(t.get(2), new Integer(1));
    assertEquals(t.get(3), new Long(2));
    assertEquals(t.get(4), new Float(2.5));
    assertEquals(t.get(5), new Double(3.14));
    assertEquals(t.get(6), "test");

    assertEquals(t.get("field0"), "default");
    assertEquals(t.get("field1"), true);
    assertEquals(t.get("field2"), new Integer(1));
    assertEquals(t.get("field3"), new Long(2));
    assertEquals(t.get("field4"), new Float(2.5));
    assertEquals(t.get("field5"), new Double(3.14));
    assertEquals(t.get("field6"), "test");

    assertEquals(t.getFieldType(0), String.class);
    assertEquals(t.getFieldType(1), Boolean.class);
    assertEquals(t.getFieldType(2), Integer.class);
    assertEquals(t.getFieldType(3), Long.class);
    assertEquals(t.getFieldType(4), Float.class);
    assertEquals(t.getFieldType(5), Double.class);
    assertEquals(t.getFieldType(6), String.class);
  }

  @Test
  public void testSerializeInstantiatedValues() throws IOException {
    Tuple tuple = SCHEMA1.instantiate("Hello world!", false,
        new Integer(5), new Long(3), new Float(1.2), new Double(2.871),
        "another string");

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

    tuple.write(dataOut);

    Tuple t = Tuple.createFrom(new DataInputStream(
        new ByteArrayInputStream(bytesOut.toByteArray())));

    assertEquals(t.get(0), "Hello world!");
    assertEquals(t.get(1), false);
    assertEquals(t.get(2), new Integer(5));
    assertEquals(t.get(3), new Long(3));
    assertEquals(t.get(4), new Float(1.2));
    assertEquals(t.get(5), new Double(2.871));
    assertEquals(t.get(6), "another string");
  }

  @Test
  public void testSerializeSetValues() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.set(0, "Hello world!");
    tuple.set(1, false);
    tuple.set(2, new Integer(5));
    tuple.set(3, new Long(3));
    tuple.set(4, new Float(1.2));
    tuple.set(5, new Double(2.871));
    tuple.set(6, "another string");

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

    tuple.write(dataOut);

    Tuple t = Tuple.createFrom(new DataInputStream(
        new ByteArrayInputStream(bytesOut.toByteArray())));

    assertEquals(t.get(0), "Hello world!");
    assertEquals(t.get(1), false);
    assertEquals(t.get(2), new Integer(5));
    assertEquals(t.get(3), new Long(3));
    assertEquals(t.get(4), new Float(1.2));
    assertEquals(t.get(5), new Double(2.871));
    assertEquals(t.get(6), "another string");
  }

  @Test
  public void testToString() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    assertEquals(tuple.toString(), "(default, true, 1, 2, 2.5, 3.14, test)");
  }

  @Test
  public void testSymbols() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    assertFalse(tuple.containsSymbol(0));
    assertFalse(tuple.containsSymbol(1));
    assertFalse(tuple.containsSymbol(2));
    assertFalse(tuple.containsSymbol(3));
    assertFalse(tuple.containsSymbol(4));
    assertFalse(tuple.containsSymbol(5));
    assertFalse(tuple.containsSymbol(6));

    assertFalse(tuple.containsSymbol("field0"));
    assertFalse(tuple.containsSymbol("field1"));
    assertFalse(tuple.containsSymbol("field2"));
    assertFalse(tuple.containsSymbol("field3"));
    assertFalse(tuple.containsSymbol("field4"));
    assertFalse(tuple.containsSymbol("field5"));
    assertFalse(tuple.containsSymbol("field6"));

    tuple.setSymbol(0, "*");
    tuple.setSymbol("field1", "*");

    assertTrue(tuple.containsSymbol(0));
    assertTrue(tuple.containsSymbol(1));
    assertFalse(tuple.containsSymbol(2));
    assertFalse(tuple.containsSymbol(3));
    assertFalse(tuple.containsSymbol(4));
    assertFalse(tuple.containsSymbol(5));
    assertFalse(tuple.containsSymbol(6));

    assertEquals(tuple.get(0), null);
    assertEquals(tuple.getSymbol(0), "*");

    assertEquals(tuple.get(1), null);
    assertEquals(tuple.getSymbol(1), "*");

    assertEquals(tuple.getFieldType(0), String.class);
    assertEquals(tuple.getFieldType(1), Boolean.class);

    assertEquals(tuple.toString(), "(*, *, 1, 2, 2.5, 3.14, test)");
  }

  @Test
  public void testSerializeSymbols() throws IOException {
    Tuple tuple = SCHEMA1.instantiate();

    tuple.setSymbol(0, "*");
    tuple.setSymbol("field1", "*");

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

    tuple.write(dataOut);

    Tuple t = Tuple.createFrom(new DataInputStream(
        new ByteArrayInputStream(bytesOut.toByteArray())));

    assertTrue(t.containsSymbol(0));
    assertTrue(t.containsSymbol(1));
    assertFalse(t.containsSymbol(2));
    assertFalse(t.containsSymbol(3));
    assertFalse(t.containsSymbol(4));
    assertFalse(t.containsSymbol(5));
    assertFalse(t.containsSymbol(6));

    assertEquals(t.get(0), null);
    assertEquals(t.getSymbol(0), "*");

    assertEquals(t.get(1), null);
    assertEquals(t.getSymbol(1), "*");

    assertEquals(tuple.getFieldType(0), String.class);
    assertEquals(tuple.getFieldType(1), Boolean.class);
  }

  public static final Schema SCHEMA2 = new Schema();
  static {
    SCHEMA2.addField("field0", Integer.class, 0);
    SCHEMA2.addField("field1", IntWritable.class, new IntWritable(0));
    SCHEMA2.addField("field2", Text.class, new Text("default"));
  }

  @Test
  public void testSerializeWritableFields() throws IOException {
    Tuple tuple = SCHEMA2.instantiate();

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

    tuple.write(dataOut);

    Tuple t = Tuple.createFrom(new DataInputStream(
        new ByteArrayInputStream(bytesOut.toByteArray())));

    assertEquals(t.get(0), 0);
    assertEquals(t.get(1), new IntWritable(0));
    assertEquals(t.get(2), new Text("default"));

    assertEquals(t.getFieldType(0), Integer.class);
    assertEquals(t.getFieldType(1), IntWritable.class);
    assertEquals(t.getFieldType(2), Text.class);
  }

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

}