pig-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ga...@apache.org
Subject svn commit: r591143 [3/4] - in /incubator/pig/branches/types: src/org/apache/pig/ src/org/apache/pig/builtin/ src/org/apache/pig/data/ src/org/apache/pig/impl/ src/org/apache/pig/impl/builtin/ src/org/apache/pig/impl/eval/ src/org/apache/pig/impl/eval/...
Date Thu, 01 Nov 2007 20:48:22 GMT
Modified: incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/IntermedResult.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/IntermedResult.java?rev=591143&r1=591142&r2=591143&view=diff
==============================================================================
--- incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/IntermedResult.java (original)
+++ incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/IntermedResult.java Thu Nov  1 13:48:16 2007
@@ -25,6 +25,7 @@
 import org.apache.pig.builtin.BinStorage;
 import org.apache.pig.data.DataBag;
 import org.apache.pig.data.Tuple;
+import org.apache.pig.data.Datum;
 import org.apache.pig.impl.PigContext;
 import org.apache.pig.impl.io.FileSpec;
 import org.apache.pig.impl.io.PigFile;
@@ -58,7 +59,7 @@
     
     public IntermedResult() {
         executed = true;
-        databag = new DataBag();
+        databag = new DataBag(Datum.DataType.TUPLE);
     }
     
     public IntermedResult(DataBag bag) {

Modified: incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POCogroup.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POCogroup.java?rev=591143&r1=591142&r2=591143&view=diff
==============================================================================
--- incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POCogroup.java (original)
+++ incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POCogroup.java Thu Nov  1 13:48:16 2007
@@ -121,7 +121,8 @@
 
             boolean done = true;
             for (int i = 0; i < inputs.length; i++) {
-                DataBag b = BagFactory.getInstance().getNewBag();
+                DataBag b =
+					BagFactory.getInstance().getNewBag(Datum.DataType.TUPLE);
 
                 while (sortedInputs[i].size() > 0) {
                     Datum g = sortedInputs[i].get(0)[0];

Modified: incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/PORead.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/PORead.java?rev=591143&r1=591142&r2=591143&view=diff
==============================================================================
--- incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/PORead.java (original)
+++ incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/PORead.java Thu Nov  1 13:48:16 2007
@@ -22,6 +22,7 @@
 
 import org.apache.pig.data.DataBag;
 import org.apache.pig.data.Tuple;
+import org.apache.pig.data.Datum;
 
 
 public class PORead extends PhysicalOperator {
@@ -30,7 +31,7 @@
 	 */
 	private static final long serialVersionUID = 1L;
 	DataBag             bag;
-    Iterator<Tuple> it;
+    Iterator<Datum> it;
 
     public PORead(DataBag bagIn, int outputType) {
     	super(outputType);
@@ -54,7 +55,7 @@
     @Override
 	public Tuple getNext() throws IOException {
         if (it.hasNext())
-            return it.next();
+            return (Tuple)it.next();
         else
             return null;
     }

Modified: incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POSort.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POSort.java?rev=591143&r1=591142&r2=591143&view=diff
==============================================================================
--- incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POSort.java (original)
+++ incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POSort.java Thu Nov  1 13:48:16 2007
@@ -24,13 +24,14 @@
 import org.apache.pig.data.BagFactory;
 import org.apache.pig.data.DataBag;
 import org.apache.pig.data.Tuple;
+import org.apache.pig.data.Datum;
 import org.apache.pig.impl.eval.EvalSpec;
 
 
 public class POSort extends PhysicalOperator {
 	static final long serialVersionUID = 1L; 
 	EvalSpec sortSpec;
-	transient Iterator<Tuple> iter;
+	transient Iterator<Datum> iter;
 	
 	
 	public POSort(EvalSpec sortSpec, int outputType) {
@@ -43,7 +44,8 @@
 	public boolean open(boolean continueFromLast) throws IOException {
 		if (!super.open(continueFromLast))
 			return false;
-		DataBag bag = BagFactory.getInstance().getNewBag();
+		DataBag bag =
+			BagFactory.getInstance().getNewBag(Datum.DataType.TUPLE);
 		
 		bag.sort(sortSpec);
 		Tuple t;
@@ -57,7 +59,7 @@
 	@Override
 	public Tuple getNext() throws IOException {
 		if (iter.hasNext())
-			return iter.next();
+			return (Tuple)iter.next();
 		else
 			return null;
 	}

Modified: incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POStore.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POStore.java?rev=591143&r1=591142&r2=591143&view=diff
==============================================================================
--- incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POStore.java (original)
+++ incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/POStore.java Thu Nov  1 13:48:16 2007
@@ -22,6 +22,7 @@
 import org.apache.pig.StoreFunc;
 import org.apache.pig.data.DataBag;
 import org.apache.pig.data.Tuple;
+import org.apache.pig.data.Datum;
 import org.apache.pig.impl.PigContext;
 import org.apache.pig.impl.io.FileSpec;
 import org.apache.pig.impl.io.PigFile;
@@ -62,7 +63,7 @@
     @Override
 	public Tuple getNext() throws IOException {
         // get all tuples from input, and store them.
-        DataBag b = new DataBag();
+        DataBag b = new DataBag(Datum.DataType.TUPLE);
         Tuple t;
         while ((t = (Tuple) inputs[0].getNext()) != null) {
             b.add(t);

Modified: incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/PhysicalPlan.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/PhysicalPlan.java?rev=591143&r1=591142&r2=591143&view=diff
==============================================================================
--- incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/PhysicalPlan.java (original)
+++ incubator/pig/branches/types/src/org/apache/pig/impl/physicalLayer/PhysicalPlan.java Thu Nov  1 13:48:16 2007
@@ -21,6 +21,7 @@
 import java.util.Map;
 
 import org.apache.pig.data.DataBag;
+import org.apache.pig.data.Datum;
 import org.apache.pig.data.Tuple;
 import org.apache.pig.impl.logicalLayer.LogicalPlan;
 
@@ -33,7 +34,7 @@
     }
 
     public DataBag exec(boolean continueFromLast) throws IOException {
-        DataBag results = new DataBag();
+        DataBag results = new DataBag(Datum.DataType.TUPLE);
 
         root.open(continueFromLast);
         Tuple t;

Added: incubator/pig/branches/types/src/org/apache/pig/impl/util/PigLogger.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/src/org/apache/pig/impl/util/PigLogger.java?rev=591143&view=auto
==============================================================================
--- incubator/pig/branches/types/src/org/apache/pig/impl/util/PigLogger.java (added)
+++ incubator/pig/branches/types/src/org/apache/pig/impl/util/PigLogger.java Thu Nov  1 13:48:16 2007
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.apache.pig.impl.util;
+
+import org.apache.log4j.Logger;
+import org.apache.log4j.Level;
+import org.apache.log4j.ConsoleAppender;
+import org.apache.log4j.PatternLayout;
+
+public class PigLogger 
+{
+
+private static Logger mLogger = null;
+private static boolean mHaveSetAppenders = false;
+
+/**
+ * Get an instance of the underlying log4j logger.  This first makes sure
+ * the PigLogger is initialized and then returns the underlying logger.
+ */ 
+public static Logger getLogger()
+{
+	if (mLogger == null) {
+		mLogger = Logger.getLogger("org.apache.pig");
+		mLogger.setAdditivity(false);
+	}
+	return mLogger;
+}
+
+/**
+ * Set up a log appender for the junit tests, this way they cn write out log
+ * messages.
+ */
+public static void setAppenderForJunit()
+{
+	if (!mHaveSetAppenders) {
+		Logger log = getLogger();
+		log.setLevel(Level.INFO);
+		ConsoleAppender screen = new ConsoleAppender(new PatternLayout());
+		screen.setThreshold(Level.INFO);
+		screen.setTarget(ConsoleAppender.SYSTEM_ERR);
+		log.addAppender(screen);
+		mHaveSetAppenders = true;
+	}
+}
+
+
+}

Modified: incubator/pig/branches/types/test/org/apache/pig/test/TestBuiltin.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/test/org/apache/pig/test/TestBuiltin.java?rev=591143&r1=591142&r2=591143&view=diff
==============================================================================
--- incubator/pig/branches/types/test/org/apache/pig/test/TestBuiltin.java (original)
+++ incubator/pig/branches/types/test/org/apache/pig/test/TestBuiltin.java Thu Nov  1 13:48:16 2007
@@ -34,11 +34,7 @@
 import org.apache.pig.EvalFunc;
 import org.apache.pig.StoreFunc;
 import org.apache.pig.builtin.*;
-import org.apache.pig.data.BagFactory;
-import org.apache.pig.data.DataAtom;
-import org.apache.pig.data.DataBag;
-import org.apache.pig.data.DataMap;
-import org.apache.pig.data.Tuple;
+import org.apache.pig.data.*;
 import org.apache.pig.PigServer.ExecType;
 import org.apache.pig.impl.builtin.ShellBagEvalFunc;
 import org.apache.pig.impl.io.FileLocalizer;
@@ -95,7 +91,7 @@
         count.exec(tup,output);
         assertTrue(output.numval() == 0);
         
-        map.put("a", new DataAtom("a"));
+        map.put("a", "a");
 
         assertFalse(isEmpty.exec(tup));
         count.exec(tup,output);
@@ -176,7 +172,8 @@
         t2.setField(0,a);
         Tuple t3 = new Tuple(1);
         t3.setField(0, b);
-        DataBag bag = BagFactory.getInstance().getNewBigBag();
+        DataBag bag =
+			BagFactory.getInstance().getNewBigBag(Datum.DataType.TUPLE);
         bag.add(t2);
         bag.add(t3);
         Tuple t4 = new Tuple(2);
@@ -195,7 +192,8 @@
         t6.setField(0,c);
         Tuple t7 = new Tuple(1);
         t7.setField(0, d);
-        DataBag bag2 = BagFactory.getInstance().getNewBigBag();    
+        DataBag bag2 =
+			BagFactory.getInstance().getNewBigBag(Datum.DataType.TUPLE);    
         for(int i = 0; i < 10; i ++) {
             bag2.add(t6);
             bag2.add(t7);
@@ -319,8 +317,10 @@
     	for (int i=0; i< numTimes; i++){
     		Tuple t = iter.next();
     		
-    		assertEquals(i+"AA", t.getBagField(0).content().next().getAtomField(0).strval());
-    		assertEquals(i+"BB", t.getBagField(1).content().next().getAtomField(0).strval());
+			Tuple t0 = (Tuple)t.getBagField(0).content().next();
+			Tuple t1 = (Tuple)t.getBagField(1).content().next();
+    		assertEquals(i+"AA", t0.getAtomField(0).strval());
+    		assertEquals(i+"BB", t1.getAtomField(0).strval());
     		
     	}
     	

Added: incubator/pig/branches/types/test/org/apache/pig/test/TestDataBag.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/test/org/apache/pig/test/TestDataBag.java?rev=591143&view=auto
==============================================================================
--- incubator/pig/branches/types/test/org/apache/pig/test/TestDataBag.java (added)
+++ incubator/pig/branches/types/test/org/apache/pig/test/TestDataBag.java Thu Nov  1 13:48:16 2007
@@ -0,0 +1,714 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.apache.pig.test;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import org.junit.Test;
+
+import org.apache.pig.data.*;
+
+/**
+ * This class will exercise the data bag data type.
+ * 
+ * @author gates
+ */
+public class TestDataBag extends junit.framework.TestCase
+{
+
+public void testDefaultConstructor() throws Exception
+{
+	DataBag bag = new DataBag(Datum.DataType.INT);
+
+	assertEquals("getType", Datum.DataType.BAG, bag.getType());
+	assertFalse("is null", bag.isNull());
+	assertTrue("bag of ints", bag.bagOf() == Datum.DataType.INT);
+
+	assertEquals("Default constructor size before", 0, bag.size());
+	DataInteger val = new DataInteger(42);
+
+	bag.add(val);
+	assertEquals("Default constructor size after", 1, bag.size());
+
+	Iterator<Datum> i = bag.content();
+	Datum d = i.next();
+
+	assertTrue("should be an integer", d.getType() == Datum.DataType.INT);
+	assertNotNull("get with entry in bag", d);
+	assertEquals("value of val", 42, ((DataInteger)d).get());
+}
+
+public void testListConstructor() throws Exception
+{
+	List<Datum> list = new ArrayList<Datum>();
+	list.add(new DataInteger(10));
+	list.add(new DataInteger(11));
+	list.add(new DataInteger(9));
+
+	DataBag bag = new DataBag(list);
+
+	assertEquals("list construct size", 3L, bag.size());
+
+	Iterator<Datum> i = bag.content();
+	Datum d = i.next();
+	assertNotNull("get first entry in bag", d);
+	assertTrue("should be an integer", d.getType() == Datum.DataType.INT);
+	assertEquals("first value of val", 10, ((DataInteger)d).get());
+	d = i.next();
+	assertNotNull("get second entry in bag", d);
+	assertTrue("should be an integer", d.getType() == Datum.DataType.INT);
+	assertEquals("second value of val", 11, ((DataInteger)d).get());
+	d = i.next();
+	assertNotNull("get third entry in bag", d);
+	assertTrue("should be an integer", d.getType() == Datum.DataType.INT);
+	assertEquals("third value of val", 9, ((DataInteger)d).get());
+	assertFalse("bag should be exhausted now", i.hasNext());
+
+	bag.add(new DataInteger(4));
+	i = bag.content();
+	d = i.next();
+	d = i.next();
+	d = i.next();
+	d = i.next();
+	assertNotNull("get fourth entry in bag", d);
+	assertTrue("should be an integer", d.getType() == Datum.DataType.INT);
+	assertEquals("fourth value of val", 4, ((DataInteger)d).get());
+	assertFalse("bag should be exhausted now", i.hasNext());
+}
+
+
+public void testBigBag() throws Exception
+{
+	DataBag bag = new DataBag(Datum.DataType.INT);
+
+	for (int i = 0; i < 10000; i++) {
+		bag.add(new DataInteger(i));
+	}
+
+	assertEquals("big size after loading", 10000, bag.size());
+
+	Iterator<Datum> i = bag.content();
+	for (int j = 0; j < 10000; j++) {
+		assertTrue("should still have data", i.hasNext());
+		Datum val = i.next();
+		assertTrue("should be an integer", val.getType() == Datum.DataType.INT);
+		assertEquals("value of val", j, ((DataInteger)val).get());
+	}
+	assertFalse("bag should be exhausted now", i.hasNext());
+}
+
+public void testToString() throws Exception
+{
+	DataBag bag = new DataBag(Datum.DataType.INT);
+
+	bag.add(new DataInteger(1));
+	bag.add(new DataInteger(1));
+	bag.add(new DataInteger(3));
+
+	assertEquals("toString", "{1, 1, 3}", bag.toString());
+}
+
+public void testEquals() throws Exception
+{
+	DataBag bag1 = new DataBag(Datum.DataType.INT);
+	DataBag bag2 = new DataBag(Datum.DataType.INT);
+
+	bag1.add(new DataInteger(3));
+	bag2.add(new DataInteger(3));
+
+	assertFalse("different object", bag1.equals(new String()));
+
+	assertTrue("same data", bag1.equals(bag2));
+
+	bag2 = new DataBag(Datum.DataType.INT);
+	bag2.add(new DataInteger(4));
+	assertFalse("different data", bag1.equals(bag2));
+
+	bag2 = new DataBag(Datum.DataType.INT);
+	bag2.add(new DataInteger(3));
+	bag2.add(new DataInteger(3));
+	assertFalse("different size", bag1.equals(bag2));
+
+	bag2 = new DataBag(Datum.DataType.LONG);
+	bag2.add(new DataLong(3));
+	assertFalse("different type of bag", bag1.equals(bag2));
+}
+
+public void testCompareTo() throws Exception
+{
+	DataBag bag1 = new DataBag(Datum.DataType.INT);
+	DataBag bag2 = new DataBag(Datum.DataType.INT);
+
+	bag1.add(new DataInteger(3));
+	bag2.add(new DataInteger(3));
+
+	assertEquals("different object less than", -1, bag1.compareTo(new String()));
+
+	Tuple t = new Tuple();
+	assertTrue("less than tuple", bag1.compareTo(t) < 0);
+	DataMap map = new DataMap();
+	assertTrue("less than map", bag1.compareTo(map) < 0);
+	DataLong l = new DataLong();
+	assertTrue("less than long", bag1.compareTo(l) < 0);
+	DataFloat f = new DataFloat();
+	assertTrue("less than float", bag1.compareTo(f) < 0);
+	DataDouble d = new DataDouble();
+	assertTrue("less than double", bag1.compareTo(d) < 0);
+	DataUnknown unk = new DataUnknown();
+	assertTrue("less than unknown", bag1.compareTo(unk) < 0);
+	DataCharArrayUtf16 utf16 = new DataCharArrayUtf16();
+	assertTrue("less than utf16", bag1.compareTo(utf16) < 0);
+
+	assertEquals("same data equal", 0,  bag1.compareTo(bag2));
+
+	bag2 = new DataBag(Datum.DataType.INT);
+	bag2.add(new DataInteger(2));
+	assertEquals("greater than bag with lesser value", 1, bag1.compareTo(bag2));
+
+	bag2 = new DataBag(Datum.DataType.INT);
+	bag2.add(new DataInteger(4));
+	assertEquals("less than bag with greater value", -1, bag1.compareTo(bag2));
+
+	bag2 = new DataBag(Datum.DataType.INT);
+	bag2.add(new DataInteger(3));
+	bag2.add(new DataInteger(4));
+	assertEquals("less than bigger bag", -1, bag1.compareTo(bag2));
+
+	bag2 = new DataBag(Datum.DataType.INT);
+	assertEquals("greater than smaller bag", 1, bag1.compareTo(bag2));
+
+	bag2 = new DataBag(Datum.DataType.LONG);
+	bag2.add(new DataLong(3));
+	assertEquals("different type of bag", -1, bag1.compareTo(bag2));
+}
+
+
+public void testWriteReadUnknown() throws Exception
+{
+	DataBag before = new DataBag(Datum.DataType.UNKNOWN);
+
+	String s = new String("zzz");
+	before.add(new DataUnknown(s.getBytes()));
+	s = new String("yyy");
+	before.add(new DataUnknown(s.getBytes()));
+	s = new String("xxx");
+	before.add(new DataUnknown(s.getBytes()));
+
+	File file = null;
+	file = File.createTempFile("DataBagUnknown", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataBag", a instanceof DataBag);
+
+	DataBag after = (DataBag)a;
+
+	assertTrue("bag of unknowns", after.bagOf() == Datum.DataType.UNKNOWN);
+	assertEquals("after read, size", 3, after.size()); 
+
+	Iterator<Datum> j = after.content();
+
+	Datum valAfter = j.next();
+	assertTrue("should be an unknown",
+		valAfter.getType() == Datum.DataType.UNKNOWN);
+	for (int i = 0; i < 3; i++) {
+		assertEquals("value of valAfter", (byte)0x7a,
+			((DataUnknown)valAfter).get()[i]);
+	}
+
+	valAfter = j.next();
+	assertTrue("should be an unknown",
+		valAfter.getType() == Datum.DataType.UNKNOWN);
+	for (int i = 0; i < 3; i++) {
+		assertEquals("value of valAfter", (byte)0x79,
+			((DataUnknown)valAfter).get()[i]);
+	}
+
+	valAfter = j.next();
+	assertTrue("should be an unknown",
+		valAfter.getType() == Datum.DataType.UNKNOWN);
+	for (int i = 0; i < 3; i++) {
+		assertEquals("value of valAfter", (byte)0x78,
+			((DataUnknown)valAfter).get()[i]);
+	}
+
+	assertFalse("should have read all values in bag", j.hasNext());
+	
+	file.delete();
+}
+
+public void testWriteReadInt() throws Exception
+{
+	DataBag before = new DataBag(Datum.DataType.INT);
+
+	before.add(new DataInteger(99));
+	before.add(new DataInteger(-98));
+	before.add(new DataInteger(97));
+
+	File file = null;
+	file = File.createTempFile("DataBagInteger", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataBag", a instanceof DataBag);
+
+	DataBag after = (DataBag)a;
+
+	assertTrue("bag of ints", after.bagOf() == Datum.DataType.INT);
+
+	assertEquals("after read, size", 3, after.size()); 
+
+	Iterator<Datum> j = after.content();
+
+	Datum val = j.next();
+	assertTrue("should be an integer", val.getType() == Datum.DataType.INT);
+	assertEquals("value of valAfter", 99, ((DataInteger)val).get());
+
+	val = j.next();
+	assertTrue("should be an integer", val.getType() == Datum.DataType.INT);
+	assertEquals("value of valAfter2", -98, ((DataInteger)val).get());
+
+	val = j.next();
+	assertTrue("should be an integer", val.getType() == Datum.DataType.INT);
+	assertEquals("value of valAfter", 97, ((DataInteger)val).get());
+
+	assertFalse("should have read all values in bag", j.hasNext());
+		
+	file.delete();
+}
+
+public void testWriteReadLong() throws Exception
+{
+	DataBag before = new DataBag(Datum.DataType.LONG);
+
+	before.add(new DataLong(99000000000L));
+	before.add(new DataLong(-98L));
+	before.add(new DataLong(97L));
+
+	File file = null;
+	file = File.createTempFile("DataBagLong", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataBag", a instanceof DataBag);
+
+	DataBag after = (DataBag)a;
+
+	assertTrue("bag of longs", after.bagOf() == Datum.DataType.LONG);
+	assertEquals("after read, size", 3, after.size()); 
+
+	Iterator<Datum> j = after.content();
+
+	Datum val = j.next();
+	assertTrue("should be a long", val.getType() == Datum.DataType.LONG);
+	assertEquals("value of valAfter", 99000000000L, ((DataLong)val).get());
+
+	val = j.next();
+	assertTrue("should be a long", val.getType() == Datum.DataType.LONG);
+	assertEquals("value of valAfter2", -98L, ((DataLong)val).get());
+
+	val = j.next();
+	assertTrue("should be a long", val.getType() == Datum.DataType.LONG);
+	assertEquals("value of valAfter", 97L, ((DataLong)val).get());
+
+	assertFalse("should have read all values in bag", j.hasNext());
+		
+	file.delete();
+}
+
+public void testWriteReadFloat() throws Exception
+{
+	DataBag before = new DataBag(Datum.DataType.FLOAT);
+
+	before.add(new DataFloat(3.2e32f));
+	before.add(new DataFloat(-9.929292e-29f));
+	before.add(new DataFloat(97.0f));
+
+	File file = null;
+	file = File.createTempFile("DataBagFloat", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataBag", a instanceof DataBag);
+
+	DataBag after = (DataBag)a;
+
+	assertTrue("bag of floats", after.bagOf() == Datum.DataType.FLOAT);
+	assertEquals("after read, size", 3, after.size()); 
+
+	Iterator<Datum> j = after.content();
+
+	Datum val = j.next();
+	assertTrue("should be a float", val.getType() == Datum.DataType.FLOAT);
+	assertEquals("value of valAfter", 3.2e32f, ((DataFloat)val).get());
+
+	val = j.next();
+	assertTrue("should be a float", val.getType() == Datum.DataType.FLOAT);
+	assertEquals("value of valAfter2", -9.929292e-29f, ((DataFloat)val).get());
+
+	val = j.next();
+	assertTrue("should be a float", val.getType() == Datum.DataType.FLOAT);
+	assertEquals("value of valAfter", 97.0f, ((DataFloat)val).get());
+
+	assertFalse("should have read all values in bag", j.hasNext());
+		
+	file.delete();
+}
+
+public void testWriteReadDouble() throws Exception
+{
+	DataBag before = new DataBag(Datum.DataType.DOUBLE);
+
+	before.add(new DataDouble(3.2e132));
+	before.add(new DataDouble(-9.929292e-129));
+	before.add(new DataDouble(97.0));
+
+	File file = null;
+	file = File.createTempFile("DataBagDouble", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataBag", a instanceof DataBag);
+
+	DataBag after = (DataBag)a;
+
+	assertTrue("bag of double", after.bagOf() == Datum.DataType.DOUBLE);
+	assertEquals("after read, size", 3, after.size()); 
+
+	Iterator<Datum> j = after.content();
+
+	Datum val = j.next();
+	assertTrue("should be a double", val.getType() == Datum.DataType.DOUBLE);
+	assertEquals("value of valAfter", 3.2e132, ((DataDouble)val).get());
+
+	val = j.next();
+	assertTrue("should be a double", val.getType() == Datum.DataType.DOUBLE);
+	assertEquals("value of valAfter2", -9.929292e-129, ((DataDouble)val).get());
+
+	val = j.next();
+	assertTrue("should be a double", val.getType() == Datum.DataType.DOUBLE);
+	assertEquals("value of valAfter", 97.0, ((DataDouble)val).get());
+
+	assertFalse("should have read all values in bag", j.hasNext());
+		
+	file.delete();
+}
+
+public void testWriteReadUtf16() throws Exception
+{
+	DataBag before = new DataBag(Datum.DataType.CHARARRAY);
+
+	before.add(new DataCharArrayUtf16("zzz"));
+	before.add(new DataCharArrayUtf16("yyy"));
+	before.add(new DataCharArrayUtf16("xxx"));
+
+	File file = null;
+	file = File.createTempFile("DataBagUtf16", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataBag", a instanceof DataBag);
+
+	DataBag after = (DataBag)a;
+
+	assertTrue("bag of chararray", after.bagOf() == Datum.DataType.CHARARRAY);
+	assertEquals("after read, size", 3, after.size()); 
+
+	Iterator<Datum> j = after.content();
+
+	Datum val = j.next();
+	assertTrue("should be a chararray", val.getType() == Datum.DataType.CHARARRAY);
+	assertTrue("encoding should be utf16",
+		((DataCharArray)val).getEncoding() == DataCharArray.Encoding.UTF16);
+	assertEquals("value of valAfter", "zzz", ((DataCharArrayUtf16)val).get());
+
+	val = j.next();
+	assertTrue("should be a chararray", val.getType() == Datum.DataType.CHARARRAY);
+	assertTrue("encoding should be utf16",
+		((DataCharArray)val).getEncoding() == DataCharArray.Encoding.UTF16);
+	assertEquals("value of valAfter2", "yyy", ((DataCharArrayUtf16)val).get());
+
+	val = j.next();
+	assertTrue("should be a chararray", val.getType() == Datum.DataType.CHARARRAY);
+	assertTrue("encoding should be utf16",
+		((DataCharArray)val).getEncoding() == DataCharArray.Encoding.UTF16);
+	assertEquals("value of valAfter", "xxx", ((DataCharArrayUtf16)val).get());
+
+	assertFalse("should have read all values in bag", j.hasNext());
+		
+	file.delete();
+}
+
+public void testWriteReadNone() throws Exception
+{
+	DataBag before = new DataBag(Datum.DataType.CHARARRAY);
+
+	String s = new String("zzz");
+	before.add(new DataCharArrayNone(s.getBytes()));
+	s = new String("yyy");
+	before.add(new DataCharArrayNone(s.getBytes()));
+	s = new String("xxx");
+	before.add(new DataCharArrayNone(s.getBytes()));
+
+	File file = null;
+	file = File.createTempFile("DataBagCharArrayNone", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataBag", a instanceof DataBag);
+
+	DataBag after = (DataBag)a;
+
+	assertTrue("bag of chararray", after.bagOf() == Datum.DataType.CHARARRAY);
+	assertEquals("after read, size", 3, after.size()); 
+
+	Iterator<Datum> j = after.content();
+
+	Datum valAfter = j.next();
+	assertTrue("should be a chararray", valAfter.getType() == Datum.DataType.CHARARRAY);
+	assertTrue("encoding should be none",
+		((DataCharArray)valAfter).getEncoding() == DataCharArray.Encoding.NONE);
+	for (int i = 0; i < 3; i++) {
+		assertEquals("value of valAfter", (byte)0x7a,
+			((DataCharArrayNone)valAfter).get()[i]);
+	}
+
+	valAfter = j.next();
+	assertTrue("should be a chararray", valAfter.getType() == Datum.DataType.CHARARRAY);
+	assertTrue("encoding should be none",
+		((DataCharArray)valAfter).getEncoding() == DataCharArray.Encoding.NONE);
+	for (int i = 0; i < 3; i++) {
+		assertEquals("value of valAfter", (byte)0x79,
+			((DataCharArrayNone)valAfter).get()[i]);
+	}
+
+	valAfter = j.next();
+	assertTrue("should be a chararray", valAfter.getType() == Datum.DataType.CHARARRAY);
+	assertTrue("encoding should be none",
+		((DataCharArray)valAfter).getEncoding() == DataCharArray.Encoding.NONE);
+	for (int i = 0; i < 3; i++) {
+		assertEquals("value of valAfter", (byte)0x78,
+			((DataCharArrayNone)valAfter).get()[i]);
+	}
+
+	assertFalse("should have read all values in bag", j.hasNext());
+	
+	file.delete();
+}
+
+public void testWriteReadMap() throws Exception
+{
+	DataBag before = new DataBag(Datum.DataType.MAP);
+
+	DataMap map = new DataMap();
+
+	DataInteger key = new DataInteger(1);
+	Datum val = new DataInteger(99);
+	map.put(key, val);
+
+	before.add(map);
+
+	File file = null;
+	file = File.createTempFile("DataBagCharArrayNone", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataBag", a instanceof DataBag);
+
+	DataBag after = (DataBag)a;
+
+	assertTrue("bag of maps", after.bagOf() == Datum.DataType.MAP);
+	assertEquals("after read, size", 1, after.size()); 
+
+	Iterator<Datum> j = after.content();
+
+	Datum v = j.next();
+	assertTrue("valAfter should be a map", v.getType() == Datum.DataType.MAP);
+	DataMap valAfter = (DataMap)v;
+
+	assertEquals("valAfter size", 1L, valAfter.size());
+
+	DataInteger nosuch = new DataInteger(-1);
+	Datum d = valAfter.get(nosuch);
+	assertTrue("after read, no such key", d.isNull());
+
+	Datum mapValAfter = valAfter.get(key);
+	assertTrue("mapValAfter isa integer", mapValAfter instanceof DataInteger);
+	assertEquals("value of valAfter", 99, ((DataInteger)mapValAfter).get());
+
+	assertFalse("should have read all values in bag", j.hasNext());
+	
+	file.delete();
+}
+
+public void testWriteReadTuple() throws Exception
+{
+	DataBag before = new DataBag(Datum.DataType.TUPLE);
+
+	Tuple t = new Tuple(1);
+	t.setField(0, new DataInteger(1));
+	before.add(t);
+
+	File file = null;
+	file = File.createTempFile("DataBagCharArrayNone", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataBag", a instanceof DataBag);
+
+	DataBag after = (DataBag)a;
+
+	assertTrue("bag of tuples", after.bagOf() == Datum.DataType.TUPLE);
+	assertEquals("after read, size", 1, after.size()); 
+
+	Iterator<Datum> j = after.content();
+
+	Datum v = j.next();
+	assertTrue("valAfter should be a tuple",
+		v.getType() == Datum.DataType.TUPLE);
+
+	Tuple valAfter = (Tuple)v;
+
+	assertEquals("valAfter size", 1L, valAfter.size());
+
+	Datum tupleValAfter = valAfter.getField(0);
+	assertTrue("tupleValAfter isa integer", tupleValAfter instanceof DataInteger);
+	assertEquals("value of valAfter", 1, ((DataInteger)tupleValAfter).get());
+
+	assertFalse("should have read all values in bag", j.hasNext());
+	
+	file.delete();
+}
+
+public void testWriteReadBag() throws Exception
+{
+	DataBag before = new DataBag(Datum.DataType.BAG);
+
+	DataBag b = new DataBag(Datum.DataType.INT);
+	b.add(new DataInteger(2));
+	before.add(b);
+
+	File file = null;
+	file = File.createTempFile("DataBagCharArrayNone", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataBag", a instanceof DataBag);
+
+	DataBag after = (DataBag)a;
+
+	assertTrue("bag of bags", after.bagOf() == Datum.DataType.BAG);
+	assertEquals("after read, size", 1, after.size()); 
+
+	Iterator<Datum> j = after.content();
+
+	Datum v = j.next();
+	assertTrue("valAfter should be a bag", v.getType() == Datum.DataType.BAG);
+	DataBag valAfter = (DataBag)v;
+
+	assertEquals("valAfter size", 1L, valAfter.size());
+
+	Iterator<Datum> k = valAfter.content();
+	Datum w = k.next();
+	assertTrue("bagValAfter should be an integer",
+		w.getType() == Datum.DataType.INT);
+	DataInteger bagValAfter = (DataInteger)w;
+
+	assertEquals("value of valAfter", 2, bagValAfter.get());
+
+	assertFalse("should have read all values in inner bag", k.hasNext());
+	assertFalse("should have read all values in bag", j.hasNext());
+	
+	file.delete();
+}
+
+}
+
+
+ 

Added: incubator/pig/branches/types/test/org/apache/pig/test/TestDataCharArrayNone.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/test/org/apache/pig/test/TestDataCharArrayNone.java?rev=591143&view=auto
==============================================================================
--- incubator/pig/branches/types/test/org/apache/pig/test/TestDataCharArrayNone.java (added)
+++ incubator/pig/branches/types/test/org/apache/pig/test/TestDataCharArrayNone.java Thu Nov  1 13:48:16 2007
@@ -0,0 +1,185 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.apache.pig.test;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+
+import org.junit.Test;
+
+import org.apache.pig.data.*;
+
+/**
+ * This class will exercise the nonenown data type.
+ * 
+ * @author gates
+ */
+public class TestDataCharArrayNone extends junit.framework.TestCase
+{
+
+public void testDefaultConstructor() throws Exception
+{
+	DataCharArrayNone none = new DataCharArrayNone();
+
+	assertEquals("getType", Datum.DataType.CHARARRAY, none.getType());
+	assertFalse("is null", none.isNull());
+	assertEquals("getEncoding", DataCharArray.Encoding.NONE, none.getEncoding());
+
+	assertEquals("Default constructor size before", 0L, none.size());
+	assertNull("Default constructor get before", none.get());
+	String s = "hello world";
+	none.set(s.getBytes());
+	assertEquals("Default constructor size after", 11L, none.size());
+	String n = new String(none.get());
+	assertEquals("Default constructor get after", "hello world", n);
+}
+
+public void testByteConstructor() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayNone none = new DataCharArrayNone(s.getBytes());
+	assertEquals("Byte constructor size before", 11L, none.size());
+	String n = new String(none.get());
+	assertEquals("Byte constructor get before", "hello world", n);
+
+	s = "goodbye world";
+	none.set(s.getBytes());
+	assertEquals("Byte constructor after size", 13L, none.size());
+	n = new String(none.get());
+	assertEquals("Byte constructor after get", "goodbye world", n);
+}
+
+public void testToString() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayNone none = new DataCharArrayNone(s.getBytes());
+	assertEquals("toString", s, none.toString());
+}
+
+public void testHashCode() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayNone none1 = new DataCharArrayNone(s.getBytes());
+	DataCharArrayNone none2 = new DataCharArrayNone(s.getBytes());
+	assertEquals("same data", none1.hashCode(), none2.hashCode());
+	s = "goodbye world";
+	DataCharArrayNone none3 = new DataCharArrayNone(s.getBytes());
+	assertFalse("different data", none1.hashCode() == none3.hashCode()); 
+}
+
+public void testEquals() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayNone none1 = new DataCharArrayNone(s.getBytes());
+	DataCharArrayNone none2 = new DataCharArrayNone(s.getBytes());
+
+	assertFalse("different object", none1.equals(s));
+
+	assertTrue("same data", none1.equals(none2));
+
+	s = "goodbye world";
+	DataCharArrayNone none3 = new DataCharArrayNone(s.getBytes());
+	assertFalse("different data", none1.equals(none3));
+}
+
+public void testCompareTo() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayNone none1 = new DataCharArrayNone(s.getBytes());
+	DataCharArrayNone none2 = new DataCharArrayNone(s.getBytes());
+
+	assertEquals("different object less than", -1, none1.compareTo(s));
+
+	DataBag bag = new DataBag(Datum.DataType.INT);
+	assertTrue("greater than bag", none1.compareTo(bag) > 0);
+	Tuple t = new Tuple();
+	assertTrue("greater than tuple", none1.compareTo(t) > 0);
+	DataMap map = new DataMap();
+	assertTrue("greater than map", none1.compareTo(map) > 0);
+	DataInteger i = new DataInteger();
+	assertTrue("greater than integer", none1.compareTo(i) > 0);
+	DataLong l = new DataLong();
+	assertTrue("greater than long", none1.compareTo(l) > 0);
+	DataFloat f = new DataFloat();
+	assertTrue("greater than float", none1.compareTo(f) > 0);
+	DataDouble d = new DataDouble();
+	assertTrue("greater than double", none1.compareTo(d) > 0);
+	DataUnknown unk = new DataUnknown();
+	assertTrue("less than unknown", none1.compareTo(unk) < 0);
+	DataCharArrayUtf16 utf16 = new DataCharArrayUtf16(s);
+	assertTrue("greater than utf16", none1.compareTo(utf16) > 0);
+
+	assertEquals("same data equal", 0,  none1.compareTo(none2));
+
+	s = "hello dollie";
+	none2 = new DataCharArrayNone(s.getBytes());
+	assertEquals("greater than unknown with greater lexigraphic value", 1, none1.compareTo(none2));
+
+	s = "hello zylophone";
+	none2 = new DataCharArrayNone(s.getBytes());
+	assertEquals("less than unknown with lower lexigraphic value", -1, none1.compareTo(none2));
+
+	s = "hello world, goodbye moon";
+	none2 = new DataCharArrayNone(s.getBytes());
+	assertEquals("less than longer unknown", -1, none1.compareTo(none2));
+
+	s = "hello worl";
+	none2 = new DataCharArrayNone(s.getBytes());
+	assertEquals("greater than shorter unknown", 1, none1.compareTo(none2));
+}
+
+public void testWriteRead() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayNone before = new DataCharArrayNone(s.getBytes());
+	File file = null;
+	file = File.createTempFile("DataCharArrayNone", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataCharArrayNone", a instanceof DataCharArrayNone);
+
+	DataCharArrayNone after = (DataCharArrayNone)a;
+		
+	byte[] beforeBytes = before.get();
+	byte[] afterBytes = after.get();
+
+	assertEquals("length", beforeBytes.length, afterBytes.length);
+	boolean same = true;
+	for (int i = 0; i < beforeBytes.length; i++) {
+		same &= beforeBytes[i] == afterBytes[i];
+	}
+	assertTrue("byte values", same);
+	file.delete();
+}
+
+}
+
+
+ 

Added: incubator/pig/branches/types/test/org/apache/pig/test/TestDataCharArrayUtf16.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/test/org/apache/pig/test/TestDataCharArrayUtf16.java?rev=591143&view=auto
==============================================================================
--- incubator/pig/branches/types/test/org/apache/pig/test/TestDataCharArrayUtf16.java (added)
+++ incubator/pig/branches/types/test/org/apache/pig/test/TestDataCharArrayUtf16.java Thu Nov  1 13:48:16 2007
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.apache.pig.test;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+
+import org.junit.Test;
+
+import org.apache.pig.data.*;
+
+/**
+ * This class will exercise the utf16nown data type.
+ * 
+ * @author gates
+ */
+public class TestDataCharArrayUtf16 extends junit.framework.TestCase
+{
+
+public void testDefaultConstructor() throws Exception
+{
+	DataCharArrayUtf16 utf16 = new DataCharArrayUtf16();
+
+	assertEquals("getType", Datum.DataType.CHARARRAY, utf16.getType());
+	assertFalse("is null", utf16.isNull());
+	assertEquals("getEncoding", DataCharArray.Encoding.UTF16, utf16.getEncoding());
+
+	assertEquals("Default constructor size before", 0L, utf16.size());
+	assertNull("Default constructor get before", utf16.get());
+	String s = "hello world";
+	utf16.set(s);
+	assertEquals("Default constructor size after", 11L, utf16.size());
+	String n = utf16.get();
+	assertEquals("Default constructor get after", "hello world", n);
+}
+
+public void testByteConstructor() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayUtf16 utf16 = new DataCharArrayUtf16(s.getBytes());
+	assertEquals("Byte constructor size before", 11L, utf16.size());
+	String n = utf16.get();
+	assertEquals("Byte constructor get before", "hello world", n);
+
+	s = "goodbye world";
+	utf16.set(s);
+	assertEquals("Byte constructor after size", 13L, utf16.size());
+	n = utf16.get();
+	assertEquals("Byte constructor after get", "goodbye world", n);
+}
+
+public void testStringConstructor() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayUtf16 utf16 = new DataCharArrayUtf16(s);
+	assertEquals("String constructor size before", 11L, utf16.size());
+	String n = utf16.get();
+	assertEquals("String constructor get before", "hello world", n);
+}
+
+public void testToString() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayUtf16 utf16 = new DataCharArrayUtf16(s);
+	assertEquals("toString", s, utf16.toString());
+}
+
+public void testHashCode() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayUtf16 utf161 = new DataCharArrayUtf16(s);
+	DataCharArrayUtf16 utf162 = new DataCharArrayUtf16(s);
+	assertEquals("same data", utf161.hashCode(), utf162.hashCode());
+	s = "goodbye world";
+	DataCharArrayUtf16 utf163 = new DataCharArrayUtf16(s);
+	assertFalse("different data", utf161.hashCode() == utf163.hashCode()); 
+}
+
+public void testEquals() throws Exception
+{
+	DataCharArrayUtf16 utf16_1 = new DataCharArrayUtf16("hello world");
+	DataCharArrayUtf16 utf16_2 = new DataCharArrayUtf16("hello world");
+
+	String s = new String("hello world");
+
+	assertFalse("different object", utf16_1.equals(s));
+
+	assertTrue("same data", utf16_1.equals(utf16_2));
+
+	DataCharArrayUtf16 utf16_3 = new DataCharArrayUtf16("goodbye world");
+	assertFalse("different data", utf16_1.equals(utf16_3));
+}
+
+public void testCompareTo() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayUtf16 utf16_1 = new DataCharArrayUtf16(s);
+	DataCharArrayUtf16 utf16_2 = new DataCharArrayUtf16(s);
+
+	assertEquals("different object less than", -1, utf16_1.compareTo(s));
+
+	DataBag bag = new DataBag(Datum.DataType.INT);
+	assertTrue("greater than bag", utf16_1.compareTo(bag) > 0);
+	Tuple t = new Tuple();
+	assertTrue("greater than tuple", utf16_1.compareTo(t) > 0);
+	DataMap map = new DataMap();
+	assertTrue("greater than map", utf16_1.compareTo(map) > 0);
+	DataInteger i = new DataInteger();
+	assertTrue("greater than integer", utf16_1.compareTo(i) > 0);
+	DataLong l = new DataLong();
+	assertTrue("greater than long", utf16_1.compareTo(l) > 0);
+	DataFloat f = new DataFloat();
+	assertTrue("greater than float", utf16_1.compareTo(f) > 0);
+	DataDouble d = new DataDouble();
+	assertTrue("greater than double", utf16_1.compareTo(d) > 0);
+	DataUnknown unk = new DataUnknown();
+	assertTrue("less than unknown", utf16_1.compareTo(unk) < 0);
+	DataCharArrayNone none = new DataCharArrayNone(s.getBytes());
+	assertTrue("less than none", utf16_1.compareTo(none) < 0);
+
+	assertEquals("same data equal", 0,  utf16_1.compareTo(utf16_2));
+
+	s = "hello dollie";
+	utf16_2 = new DataCharArrayUtf16(s);
+	assertTrue("greater than unknown with greater lexigraphic value", utf16_1.compareTo(utf16_2) > 0);
+
+	s = "hello zylophone";
+	utf16_2 = new DataCharArrayUtf16(s);
+	assertTrue("less than unknown with lower lexigraphic value", utf16_1.compareTo(utf16_2) < 0);
+
+	s = "hello world, goodbye moon";
+	utf16_2 = new DataCharArrayUtf16(s);
+	assertTrue("less than longer unknown", utf16_1.compareTo(utf16_2) < 0);
+
+	s = "hello worl";
+	utf16_2 = new DataCharArrayUtf16(s);
+	assertTrue("greater than shorter unknown", utf16_1.compareTo(utf16_2) > 0);
+}
+
+
+public void testWriteRead() throws Exception
+{
+	String s = "hello world";
+	DataCharArrayUtf16 before = new DataCharArrayUtf16(s);
+	File file = null;
+	file = File.createTempFile("DataCharArrayUtf16", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataCharArrayUtf16", a instanceof DataCharArrayUtf16);
+
+	DataCharArrayUtf16 after = (DataCharArrayUtf16)a;
+		
+	assertEquals("after read/write", before.get(), after.get());
+
+	file.delete();
+}
+
+}
+
+
+ 

Added: incubator/pig/branches/types/test/org/apache/pig/test/TestDataDouble.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/test/org/apache/pig/test/TestDataDouble.java?rev=591143&view=auto
==============================================================================
--- incubator/pig/branches/types/test/org/apache/pig/test/TestDataDouble.java (added)
+++ incubator/pig/branches/types/test/org/apache/pig/test/TestDataDouble.java Thu Nov  1 13:48:16 2007
@@ -0,0 +1,151 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * fstributed with this work for adftional information
+ * regarfng copyright ownership.  The ASF licenses this file
+ * to you 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
+ * fstributed under the License is fstributed 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 org.apache.pig.test;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+
+import org.junit.Test;
+
+import org.apache.pig.data.*;
+
+/**
+ * This class will exercise the fnown data type.
+ * 
+ * @author gates
+ */
+public class TestDataDouble extends junit.framework.TestCase
+{
+
+public void testDefaultConstructor() throws Exception
+{
+	DataDouble d = new DataDouble();
+
+	assertEquals("getType", Datum.DataType.DOUBLE, d.getType());
+	assertFalse("is null", d.isNull());
+
+	assertEquals("Default constructor get before", 0.0, d.get());
+	d.set(0.1);
+	assertEquals("Default constructor get after", 0.1, d.get());
+}
+
+public void testValueConstructor() throws Exception
+{
+	DataDouble d = new DataDouble(2.99792458e108);
+	assertEquals("Byte constructor get before", 2.99792458e108, d.get());
+
+	d.set(1.60217653e-149);
+	assertEquals("Byte constructor after get", 1.60217653e-149, d.get());
+}
+
+public void testToString() throws Exception
+{
+	DataDouble d = new DataDouble(-99.3234);
+	assertEquals("toString", "-99.3234", d.toString());
+}
+
+public void testHashCode() throws Exception
+{
+	String s = "hello world";
+	DataDouble d1 = new DataDouble(8.2);
+	DataDouble d2 = new DataDouble(8.2);
+	assertEquals("same data", d1.hashCode(), d2.hashCode());
+	s = "goodbye world";
+	DataDouble f3 = new DataDouble(9.3);
+	assertFalse("ffferent data", d1.hashCode() == f3.hashCode()); 
+}
+
+public void testEquals() throws Exception
+{
+	DataDouble d1 = new DataDouble(-1.2393);
+	DataDouble d2 = new DataDouble(-1.2393);
+
+	Double dd = new Double(-1.2393);
+
+	assertFalse("different object", d1.equals(dd));
+
+	assertTrue("same data", d1.equals(d2));
+
+	DataDouble d3 = new DataDouble(37.2322e39);
+	assertFalse("different data", d1.equals(d3));
+}
+
+public void testCompareTo() throws Exception
+{
+	DataDouble d1 = new DataDouble(3.1415);
+	DataDouble d2 = new DataDouble(3.1415);
+
+	assertEquals("different object less than", -1, d1.compareTo(new Integer(3)));
+
+	DataBag bag = new DataBag(Datum.DataType.INT);
+	assertTrue("greater than bag", d1.compareTo(bag) > 0);
+	Tuple t = new Tuple();
+	assertTrue("greater than tuple", d1.compareTo(t) > 0);
+	DataMap map = new DataMap();
+	assertTrue("greater than map", d1.compareTo(map) > 0);
+	DataInteger i = new DataInteger(3);
+	assertTrue("greater than integer", d1.compareTo(i) > 0);
+	DataLong dl = new DataLong();
+	assertTrue("greater than long", d1.compareTo(dl) > 0);
+	DataFloat f = new DataFloat(3.1415f);
+	assertTrue("greater than float", d1.compareTo(f) > 0);
+	DataUnknown unk = new DataUnknown();
+	assertTrue("less than unknown", d1.compareTo(unk) < 0);
+	DataCharArrayUtf16 utf16 = new DataCharArrayUtf16("hello world");
+	assertTrue("less than utf16", d1.compareTo(utf16) < 0);
+
+	assertEquals("same data equal", 0,  d1.compareTo(d2));
+
+	d2 = new DataDouble(4.0);
+	assertEquals("less than unknown with greater value", -1, d1.compareTo(d2));
+
+	d2 = new DataDouble(3.0);
+	assertEquals("greater than unknown with lower value", 1, d1.compareTo(d2));
+}
+
+public void testWriteRead() throws Exception
+{
+	DataDouble before = new DataDouble(17.9);
+	File file = null;
+	file = File.createTempFile("DataDouble", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataDouble", a instanceof DataDouble);
+
+	DataDouble after = (DataDouble)a;
+		
+	assertEquals("after read/write", before.get(), after.get());
+	file.delete();
+}
+
+}
+
+
+ 

Added: incubator/pig/branches/types/test/org/apache/pig/test/TestDataFloat.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/test/org/apache/pig/test/TestDataFloat.java?rev=591143&view=auto
==============================================================================
--- incubator/pig/branches/types/test/org/apache/pig/test/TestDataFloat.java (added)
+++ incubator/pig/branches/types/test/org/apache/pig/test/TestDataFloat.java Thu Nov  1 13:48:16 2007
@@ -0,0 +1,151 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * fstributed with this work for adftional information
+ * regarfng copyright ownership.  The ASF licenses this file
+ * to you 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
+ * fstributed under the License is fstributed 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 org.apache.pig.test;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+
+import org.junit.Test;
+
+import org.apache.pig.data.*;
+
+/**
+ * This class will exercise the fnown data type.
+ * 
+ * @author gates
+ */
+public class TestDataFloat extends junit.framework.TestCase
+{
+
+public void testDefaultConstructor() throws Exception
+{
+	DataFloat f = new DataFloat();
+
+	assertEquals("getType", Datum.DataType.FLOAT, f.getType());
+	assertFalse("is null", f.isNull());
+
+	assertEquals("Default constructor get before", 0.0f, f.get());
+	f.set(0.1f);
+	assertEquals("Default constructor get after", 0.1f, f.get());
+}
+
+public void testValueConstructor() throws Exception
+{
+	DataFloat f = new DataFloat(2.99792458e8f);
+	assertEquals("Byte constructor get before", 2.99792458e8f, f.get());
+
+	f.set(1.60217653e-14f);
+	assertEquals("Byte constructor after get", 1.60217653e-14f, f.get());
+}
+
+public void testToString() throws Exception
+{
+	DataFloat f = new DataFloat(-99.3234f);
+	assertEquals("toString", "-99.3234", f.toString());
+}
+
+public void testHashCode() throws Exception
+{
+	String s = "hello world";
+	DataFloat f1 = new DataFloat(8.2f);
+	DataFloat f2 = new DataFloat(8.2f);
+	assertEquals("same data", f1.hashCode(), f2.hashCode());
+	s = "goodbye world";
+	DataFloat f3 = new DataFloat(9.3f);
+	assertFalse("ffferent data", f1.hashCode() == f3.hashCode()); 
+}
+
+public void testEquals() throws Exception
+{
+	DataFloat f1 = new DataFloat(-1.0f);
+	DataFloat f2 = new DataFloat(-1.0f);
+
+	Float ff = new Float(-1.0f);
+
+	assertFalse("different object", f1.equals(ff));
+
+	assertTrue("same data", f1.equals(f2));
+
+	DataFloat f3 = new DataFloat(37.393f);
+	assertFalse("different data", f1.equals(f3));
+}
+
+public void testCompareTo() throws Exception
+{
+	DataFloat f1 = new DataFloat(3.1415f);
+	DataFloat f2 = new DataFloat(3.1415f);
+
+	assertEquals("different object less than", -1, f1.compareTo(new Integer(3)));
+
+	DataBag bag = new DataBag(Datum.DataType.INT);
+	assertTrue("greater than bag", f1.compareTo(bag) > 0);
+	Tuple t = new Tuple();
+	assertTrue("greater than tuple", f1.compareTo(t) > 0);
+	DataMap map = new DataMap();
+	assertTrue("greater than map", f1.compareTo(map) > 0);
+	DataInteger i = new DataInteger(3);
+	assertTrue("greater than integer", f1.compareTo(i) > 0);
+	DataLong dl = new DataLong();
+	assertTrue("greater than long", f1.compareTo(dl) > 0);
+	DataDouble d = new DataDouble(3.1415);
+	assertTrue("less than double", f1.compareTo(d) < 0);
+	DataUnknown unk = new DataUnknown();
+	assertTrue("less than unknown", f1.compareTo(unk) < 0);
+	DataCharArrayUtf16 utf16 = new DataCharArrayUtf16("hello world");
+	assertTrue("less than utf16", f1.compareTo(utf16) < 0);
+
+	assertEquals("same data equal", 0,  f1.compareTo(f2));
+
+	f2 = new DataFloat(4.0f);
+	assertEquals("less than unknown with greater value", -1, f1.compareTo(f2));
+
+	f2 = new DataFloat(3.0f);
+	assertEquals("greater than unknown with lower value", 1, f1.compareTo(f2));
+}
+
+public void testWriteRead() throws Exception
+{
+	DataFloat before = new DataFloat(17.9f);
+	File file = null;
+	file = File.createTempFile("DataFloat", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataFloat", a instanceof DataFloat);
+
+	DataFloat after = (DataFloat)a;
+		
+	assertEquals("after read/write", before.get(), after.get());
+	file.delete();
+}
+
+}
+
+
+ 

Added: incubator/pig/branches/types/test/org/apache/pig/test/TestDataInteger.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/test/org/apache/pig/test/TestDataInteger.java?rev=591143&view=auto
==============================================================================
--- incubator/pig/branches/types/test/org/apache/pig/test/TestDataInteger.java (added)
+++ incubator/pig/branches/types/test/org/apache/pig/test/TestDataInteger.java Thu Nov  1 13:48:16 2007
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.apache.pig.test;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+
+import org.junit.Test;
+
+import org.apache.pig.data.*;
+
+/**
+ * This class will exercise the dinown data type.
+ * 
+ * @author gates
+ */
+public class TestDataInteger extends junit.framework.TestCase
+{
+
+public void testDefaultConstructor() throws Exception
+{
+	DataInteger di = new DataInteger();
+
+	assertEquals("getType", Datum.DataType.INT, di.getType());
+	assertFalse("is null", di.isNull());
+
+	assertEquals("Default constructor get before", 0, di.get());
+	di.set(11);
+	assertEquals("Default constructor get after", 11, di.get());
+}
+
+public void testValueConstructor() throws Exception
+{
+	DataInteger di = new DataInteger(3231132);
+	assertEquals("Byte constructor get before", 3231132, di.get());
+
+	di.set(-1);
+	assertEquals("Byte constructor after get", -1, di.get());
+}
+
+public void testToString() throws Exception
+{
+	DataInteger di = new DataInteger(99);
+	assertEquals("toString", "99", di.toString());
+}
+
+public void testHashCode() throws Exception
+{
+	DataInteger di1 = new DataInteger(8);
+	DataInteger di2 = new DataInteger(8);
+	assertEquals("same data", di1.hashCode(), di2.hashCode());
+	DataInteger di3 = new DataInteger(9);
+	assertFalse("different data", di1.hashCode() == di3.hashCode()); 
+}
+
+public void testEquals() throws Exception
+{
+	DataInteger di1 = new DataInteger(-1);
+	DataInteger di2 = new DataInteger(-1);
+
+	Integer ii = new Integer(-1);
+
+	assertFalse("different object", di1.equals(ii));
+
+	assertTrue("same data", di1.equals(di2));
+
+	DataInteger di3 = new DataInteger(37);
+	assertFalse("different data", di1.equals(di3));
+}
+
+public void testCompareTo() throws Exception
+{
+	DataInteger di1 = new DataInteger(3);
+	DataInteger di2 = new DataInteger(3);
+
+	assertEquals("different object less than", -1, di1.compareTo(new Integer(3)));
+
+	DataBag bag = new DataBag(Datum.DataType.INT);
+	assertTrue("greater than bag", di1.compareTo(bag) > 0);
+	Tuple t = new Tuple();
+	assertTrue("greater than tuple", di1.compareTo(t) > 0);
+	DataMap map = new DataMap();
+	assertTrue("greater than map", di1.compareTo(map) > 0);
+	DataLong l = new DataLong(3);
+	assertTrue("less than long", di1.compareTo(l) < 0);
+	DataFloat f = new DataFloat();
+	assertTrue("less than float", di1.compareTo(f) < 0);
+	DataDouble d = new DataDouble();
+	assertTrue("less than double", di1.compareTo(d) < 0);
+	DataUnknown unk = new DataUnknown();
+	assertTrue("less than unknown", di1.compareTo(unk) < 0);
+	DataCharArrayUtf16 utf16 = new DataCharArrayUtf16("hello world");
+	assertTrue("less than none", di1.compareTo(utf16) < 0);
+
+	assertEquals("same data equal", 0,  di1.compareTo(di2));
+
+	di2 = new DataInteger(5);
+	assertEquals("less than int with greater value", -1, di1.compareTo(di2));
+
+	di2 = new DataInteger(1);
+	assertEquals("greater than int with lower value", 1, di1.compareTo(di2));
+}
+
+
+public void testWriteRead() throws Exception
+{
+	DataInteger before = new DataInteger(17);
+	File file = null;
+	file = File.createTempFile("DataInteger", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataInteger", a instanceof DataInteger);
+
+	DataInteger after = (DataInteger)a;
+		
+	assertEquals("after read/write", before.get(), after.get());
+	file.delete();
+}
+
+}
+
+
+ 

Added: incubator/pig/branches/types/test/org/apache/pig/test/TestDataLong.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/test/org/apache/pig/test/TestDataLong.java?rev=591143&view=auto
==============================================================================
--- incubator/pig/branches/types/test/org/apache/pig/test/TestDataLong.java (added)
+++ incubator/pig/branches/types/test/org/apache/pig/test/TestDataLong.java Thu Nov  1 13:48:16 2007
@@ -0,0 +1,151 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * dlstributed with this work for addltional information
+ * regardlng copyright ownership.  The ASF licenses this file
+ * to you 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
+ * dlstributed under the License is dlstributed 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 org.apache.pig.test;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+
+import org.junit.Test;
+
+import org.apache.pig.data.*;
+
+/**
+ * This class will exercise the dlnown data type.
+ * 
+ * @author gates
+ */
+public class TestDataLong extends junit.framework.TestCase
+{
+
+public void testDefaultConstructor() throws Exception
+{
+	DataLong dl = new DataLong();
+
+	assertEquals("getType", Datum.DataType.LONG, dl.getType());
+	assertFalse("is null", dl.isNull());
+
+	assertEquals("Default constructor get before", 0L, dl.get());
+	dl.set(11L);
+	assertEquals("Default constructor get after", 11L, dl.get());
+}
+
+public void testValueConstructor() throws Exception
+{
+	DataLong dl = new DataLong(323113232322L);
+	assertEquals("Byte constructor get before", 323113232322L, dl.get());
+
+	dl.set(-1L);
+	assertEquals("Byte constructor after get", -1L, dl.get());
+}
+
+public void testToString() throws Exception
+{
+	DataLong dl = new DataLong(-323113232322L);
+	assertEquals("toString", "-323113232322", dl.toString());
+}
+
+public void testHashCode() throws Exception
+{
+	String s = "hello world";
+	DataLong dl1 = new DataLong(8L);
+	DataLong dl2 = new DataLong(8L);
+	assertEquals("same data", dl1.hashCode(), dl2.hashCode());
+	s = "goodbye world";
+	DataLong dl3 = new DataLong(9L);
+	assertFalse("dlfferent data", dl1.hashCode() == dl3.hashCode()); 
+}
+
+public void testEquals() throws Exception
+{
+	DataLong dl1 = new DataLong(-1L);
+	DataLong dl2 = new DataLong(-1L);
+
+	Long ll = new Long(-1L);
+
+	assertFalse("different object", dl1.equals(ll));
+
+	assertTrue("same data", dl1.equals(dl2));
+
+	DataLong dl3 = new DataLong(37L);
+	assertFalse("different data", dl1.equals(dl3));
+}
+
+public void testCompareTo() throws Exception
+{
+	DataLong dl1 = new DataLong(3);
+	DataLong dl2 = new DataLong(3);
+
+	assertEquals("different object less than", -1, dl1.compareTo(new Integer(3)));
+
+	DataBag bag = new DataBag(Datum.DataType.INT);
+	assertTrue("greater than bag", dl1.compareTo(bag) > 0);
+	Tuple t = new Tuple();
+	assertTrue("greater than tuple", dl1.compareTo(t) > 0);
+	DataMap map = new DataMap();
+	assertTrue("greater than map", dl1.compareTo(map) > 0);
+	DataInteger i = new DataInteger(3);
+	assertTrue("greater than integer", dl1.compareTo(i) > 0);
+	DataFloat f = new DataFloat();
+	assertTrue("less than float", dl1.compareTo(f) < 0);
+	DataDouble d = new DataDouble();
+	assertTrue("less than double", dl1.compareTo(d) < 0);
+	DataUnknown unk = new DataUnknown();
+	assertTrue("less than unknown", dl1.compareTo(unk) < 0);
+	DataCharArrayUtf16 utf16 = new DataCharArrayUtf16("hello world");
+	assertTrue("less than utf16", dl1.compareTo(utf16) < 0);
+
+	assertEquals("same data equal", 0,  dl1.compareTo(dl2));
+
+	dl2 = new DataLong(5);
+	assertEquals("less than unknown with greater value", -1, dl1.compareTo(dl2));
+
+	dl2 = new DataLong(1);
+	assertEquals("greater than unknown with lower value", 1, dl1.compareTo(dl2));
+}
+
+public void testWriteRead() throws Exception
+{
+	DataLong before = new DataLong(17L);
+	File file = null;
+	file = File.createTempFile("DataLong", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataLong", a instanceof DataLong);
+
+	DataLong after = (DataLong)a;
+		
+	assertEquals("after read/write", before.get(), after.get());
+	file.delete();
+}
+
+}
+
+
+ 

Added: incubator/pig/branches/types/test/org/apache/pig/test/TestDataMap.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/test/org/apache/pig/test/TestDataMap.java?rev=591143&view=auto
==============================================================================
--- incubator/pig/branches/types/test/org/apache/pig/test/TestDataMap.java (added)
+++ incubator/pig/branches/types/test/org/apache/pig/test/TestDataMap.java Thu Nov  1 13:48:16 2007
@@ -0,0 +1,302 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.apache.pig.test;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import org.junit.Test;
+
+import org.apache.pig.data.*;
+
+/**
+ * This class will exercise the data map data type.
+ * 
+ * @author gates
+ */
+public class TestDataMap extends junit.framework.TestCase
+{
+
+public void testDefaultConstructor() throws Exception
+{
+	DataMap map = new DataMap();
+
+	assertEquals("getType", Datum.DataType.MAP, map.getType());
+	assertFalse("is null", map.isNull());
+
+	assertEquals("Default constructor size before", 0, map.size());
+	String s = "hello world";
+	DataUnknown key = new DataUnknown(s.getBytes());
+	Datum d = map.get(key);
+	assertTrue("get with no entries in map", d.isNull());
+	DataInteger val = new DataInteger(42);
+
+	map.put(key, val);
+	assertEquals("Default constructor size after", 1, map.size());
+	d = map.get(key);
+	assertNotNull("get with entry in map", d);
+	assertTrue("val isa integer", d instanceof DataInteger);
+	assertEquals("value of val", 42, ((DataInteger)d).get());
+}
+
+public void testBigMap() throws Exception
+{
+	DataMap map = new DataMap();
+
+	for (int i = 0; i < 10000; i++) {
+		Integer ii = new Integer(i);
+		DataCharArrayUtf16 key = new DataCharArrayUtf16(ii.toString());
+		DataInteger val = new DataInteger(i);
+		map.put(key, val);
+	}
+
+	assertEquals("big size after loading", 10000, map.size());
+	DataCharArrayUtf16 key = new DataCharArrayUtf16("no such key");
+	Datum d = map.get(key);
+	assertTrue("get no such key", d.isNull());
+
+	for (int i = 9999; i >= 0; i--) {
+		Integer ii = new Integer(i);
+		key = new DataCharArrayUtf16(ii.toString());
+		Datum val = map.get(key);
+		assertFalse("val should not be null", val.isNull());
+		assertTrue("val isa integer", val instanceof DataInteger);
+		assertEquals("value of val", i, ((DataInteger)val).get());
+	}
+}
+
+public void testToString() throws Exception
+{
+	DataMap map = new DataMap();
+
+	DataCharArrayUtf16 key = new DataCharArrayUtf16("aaa");
+	Datum val = new DataLong(1L);
+	map.put(key, val);
+	key = new DataCharArrayUtf16("bbb");
+	val = new DataFloat(2.0f);
+	map.put(key, val);
+	key = new DataCharArrayUtf16("ccc");
+	val = new DataDouble(3.14159);
+	map.put(key, val);
+
+	assertEquals("toString", "[aaa#1, ccc#3.14159, bbb#2.0]", map.toString());
+}
+
+public void testHashCode() throws Exception
+{
+	DataMap map1 = new DataMap();
+	DataCharArrayUtf16 key1 = new DataCharArrayUtf16("aaa");
+	DataLong val1 = new DataLong(1L);
+	map1.put(key1, val1);
+
+	DataMap map2 = new DataMap();
+	DataCharArrayUtf16 key2 = new DataCharArrayUtf16("aaa");
+	DataLong val2 = new DataLong(1L);
+	map2.put(key2, val2);
+
+	assertEquals("same data", map1.hashCode(), map2.hashCode());
+
+	DataMap map3 = new DataMap();
+	DataCharArrayUtf16 key3 = new DataCharArrayUtf16("aaa");
+	DataLong val3 = new DataLong(2L);
+	map3.put(key3, val3);
+
+	assertFalse("different data", map1.hashCode() == map3.hashCode()); 
+}
+
+public void testEquals() throws Exception
+{
+	DataMap map1 = new DataMap();
+	DataMap map2 = new DataMap();
+
+	map1.put(new DataInteger(3), new DataInteger(4));
+	map2.put(new DataInteger(3), new DataInteger(4));
+
+	assertFalse("different object", map1.equals(new String()));
+
+	assertTrue("same data", map1.equals(map2));
+
+	map2 = new DataMap();
+	map2.put(new DataInteger(3), new DataInteger(5));
+	assertFalse("different data", map1.equals(map2));
+
+	map2 = new DataMap();
+	map2.put(new DataInteger(3), new DataInteger(4));
+	map2.put(new DataInteger(4), new DataInteger(4));
+	assertFalse("different size", map1.equals(map2));
+}
+
+public void testCompareTo() throws Exception
+{
+	DataMap map1 = new DataMap();
+	DataMap map2 = new DataMap();
+
+	map1.put(new DataInteger(3), new DataInteger(4));
+	map2.put(new DataInteger(3), new DataInteger(4));
+
+	assertEquals("different object less than", -1, map1.compareTo(new String()));
+
+	DataBag bag = new DataBag(Datum.DataType.INT);
+	assertTrue("greater than bag", map1.compareTo(bag) > 0);
+	Tuple t = new Tuple();
+	assertTrue("greater than tuple", map1.compareTo(t) > 0);
+	DataInteger i = new DataInteger();
+	assertTrue("less than integer", map1.compareTo(i) < 0);
+	DataLong l = new DataLong();
+	assertTrue("less than long", map1.compareTo(l) < 0);
+	DataFloat f = new DataFloat();
+	assertTrue("less than float", map1.compareTo(f) < 0);
+	DataDouble d = new DataDouble();
+	assertTrue("less than double", map1.compareTo(d) < 0);
+	DataUnknown unk = new DataUnknown();
+	assertTrue("less than unknown", map1.compareTo(unk) < 0);
+	DataCharArrayUtf16 utf16 = new DataCharArrayUtf16();
+	assertTrue("less than utf16", map1.compareTo(utf16) < 0);
+
+	assertEquals("same data equal", 0, map1.compareTo(map2));
+
+	map2 = new DataMap();
+	map2.put(new DataInteger(2), new DataInteger(4));
+	assertTrue("greater than map with lesser key", map1.compareTo(map2) > 0);
+
+	map2 = new DataMap();
+	map2.put(new DataInteger(3), new DataInteger(3));
+	assertTrue("greater than map with lesser value", map1.compareTo(map2) > 0);
+
+	map2 = new DataMap();
+	map2.put(new DataInteger(4), new DataInteger(4));
+	assertTrue("less than map with greater key", map1.compareTo(map2) < 0);
+
+	map2 = new DataMap();
+	map2.put(new DataInteger(3), new DataInteger(5));
+	assertTrue("less than map with greater value", map1.compareTo(map2) < 0);
+
+	map2 = new DataMap();
+	map2.put(new DataInteger(3), new DataInteger(5));
+	map2.put(new DataInteger(4), new DataInteger(5));
+	assertTrue("less than bigger map", map1.compareTo(map2) < 0);
+
+	map2 = new DataMap();
+	assertTrue("greater than smaller map", map1.compareTo(map2) > 0);
+}
+
+public void testWriteRead() throws Exception
+{
+	DataMap before = new DataMap();
+
+	String s = new String("aaa");
+	DataUnknown keyUnknown = new DataUnknown(s.getBytes());
+	s = new String("zzz");
+	Datum val = new DataUnknown(s.getBytes());
+	before.put(keyUnknown, val);
+
+	DataInteger keyInt = new DataInteger(1);
+	val = new DataInteger(99);
+	before.put(keyInt, val);
+
+	DataLong keyLong = new DataLong(1L);
+	val = new DataLong(99000000000L);
+	before.put(keyLong, val);
+
+	DataFloat keyFloat = new DataFloat(1.0f);
+	val = new DataFloat(3.2e32f);
+	before.put(keyFloat, val);
+
+	DataDouble keyDouble = new DataDouble(1.0);
+	val = new DataDouble(3.2e132);
+	before.put(keyDouble, val);
+
+	DataCharArrayUtf16 keyUtf16 = new DataCharArrayUtf16("aaa");
+	val = new DataCharArrayUtf16("yyy");
+	before.put(keyUtf16, val);
+
+	s = new String("aaa");
+	DataCharArrayNone keyNone = new DataCharArrayNone(s.getBytes());
+	s = new String("xxx");
+	val = new DataCharArrayNone(s.getBytes());
+	before.put(keyNone, val);
+
+	File file = null;
+	file = File.createTempFile("DataMapUnknown", "put");
+	FileOutputStream fos = new FileOutputStream(file);
+	DataOutput out = new DataOutputStream(fos);
+	before.write(out);
+	fos.close();
+
+	FileInputStream fis = new FileInputStream(file);
+	DataInput in = new DataInputStream(fis);
+	Datum a = DatumImpl.readDatum(in);
+
+	assertTrue("isa DataMap", a instanceof DataMap);
+
+	DataMap after = (DataMap)a;
+
+	assertEquals("after read, size", 7, after.size()); 
+
+	s = new String("no such key");
+	DataUnknown nosuch = new DataUnknown(s.getBytes());
+	Datum d = after.get(nosuch);
+	assertTrue("after read, no such key", d.isNull());
+
+	Datum valAfter = after.get(keyUnknown);
+	assertTrue("valAfter isa integer", valAfter instanceof DataUnknown);
+	for (int i = 0; i < 3; i++) {
+		assertEquals("value of valAfter", (byte)0x7a,
+			((DataUnknown)valAfter).get()[i]);
+	}
+
+	valAfter = after.get(keyInt);
+	assertTrue("valAfter isa integer", valAfter instanceof DataInteger);
+	assertEquals("value of valAfter", 99, ((DataInteger)valAfter).get());
+
+	valAfter = after.get(keyLong);
+	assertTrue("valAfter isa long", valAfter instanceof DataLong);
+	assertEquals("value of valAfter", 99000000000L, ((DataLong)valAfter).get());
+
+	valAfter = after.get(keyFloat);
+	assertTrue("valAfter isa float", valAfter instanceof DataFloat);
+	assertEquals("value of valAfter", 3.2e32f, ((DataFloat)valAfter).get());
+
+	valAfter = after.get(keyDouble);
+	assertTrue("valAfter isa double", valAfter instanceof DataDouble);
+	assertEquals("value of valAfter", 3.2e132, ((DataDouble)valAfter).get());
+
+	valAfter = after.get(keyUtf16);
+	assertTrue("valAfter isa utf16", valAfter instanceof DataCharArrayUtf16);
+	assertEquals("value of valAfter", "yyy", ((DataCharArrayUtf16)valAfter).get());
+
+	valAfter = after.get(keyNone);
+	assertTrue("valAfter isa none", valAfter instanceof DataCharArrayNone);
+	for (int i = 0; i < 3; i++) {
+		assertEquals("value of valAfter", (byte)0x78,
+			((DataCharArrayNone)valAfter).get()[i]);
+	}
+
+	file.delete();
+}
+
+}
+
+
+ 

Modified: incubator/pig/branches/types/test/org/apache/pig/test/TestDataModel.java
URL: http://svn.apache.org/viewvc/incubator/pig/branches/types/test/org/apache/pig/test/TestDataModel.java?rev=591143&r1=591142&r2=591143&view=diff
==============================================================================
--- incubator/pig/branches/types/test/org/apache/pig/test/TestDataModel.java (original)
+++ incubator/pig/branches/types/test/org/apache/pig/test/TestDataModel.java Thu Nov  1 13:48:16 2007
@@ -73,6 +73,7 @@
         assertFalse(da1.compareTo(da2) > 0);
     }
 
+	/* Replaced by TestTuple.java
     @Test
     public void testTuple() throws Exception {
         int arity = 5;
@@ -159,7 +160,9 @@
         n1.appendTuple(n2);
         assertTrue(n1.arity() == n1Arity + n2Arity);
     }
+	*/
 
+	/* Replaced by TestDataBag.java 
     @Test
     public void testDataBag() throws Exception {
         int[] input1 = { 1, 2, 3, 4, 5 };
@@ -195,6 +198,7 @@
         }   
         assertTrue(caught);
     }
+	*/
 
     @Test
     
@@ -211,10 +215,11 @@
     private void testBigDataBag(long freeMemoryToMaintain, int numItems) throws Exception {
     	BigDataBag.FREE_MEMORY_TO_MAINTAIN = freeMemoryToMaintain;
     	File tmp = File.createTempFile("test", "bag").getParentFile();
-        BigDataBag bag = new BigDataBag(tmp);
-        Iterator<Tuple> it;
+        BigDataBag bag = new BigDataBag(Datum.DataType.TUPLE, tmp);
+        Iterator<Datum> it;
         int count;
-        String last;
+        //String last;
+		Tuple lastT = null;
     
         Random r = new Random();
         
@@ -237,7 +242,7 @@
         it = bag.content();
         count = 0;
         while(it.hasNext()) {
-            Tuple t = it.next();
+            Tuple t = (Tuple)it.next();
             int ix = Integer.parseInt(t.getAtomField(0).strval(), 16);
             assertTrue(Integer.toString(ix).equals(t.getAtomField(1).strval()));
             assertEquals(lastI+1, ix);
@@ -262,12 +267,17 @@
         
         it = bag.content();
         count = 0;
-        last= "";
+        // last= "";
+		lastT = new Tuple();
         while(it.hasNext()) {
-            Tuple t = it.next();
+            Tuple t = (Tuple)it.next();
+			/*
             String next = t.getAtomField(0).strval();
             assertTrue(last.compareTo(next)<=0);
             last = next;
+			*/
+			assertTrue("last should be <= next", lastT.compareTo(t) <= 0);
+			lastT = t;
             count++;
         }
 
@@ -288,12 +298,17 @@
 
         it = bag.content();
         count = 0;
-        last= "";
+        //last= "";
+		lastT = new Tuple();
         while(it.hasNext()) {
-            Tuple t = it.next();
+            Tuple t = (Tuple)it.next();
+			/*
             String next = t.getAtomField(0).strval();
             assertTrue(last.compareTo(next)<=0);
             last = next;
+			*/
+			assertTrue("last should be <= next", lastT.compareTo(t) <= 0);
+			lastT = t;
             count++;
         }
 
@@ -316,12 +331,17 @@
 
         it = bag.content();
         count = 0;
-        last= "";
+        //last= "";
+		lastT = new Tuple();
         while(it.hasNext()) {
-            Tuple t = it.next();
+            Tuple t = (Tuple)it.next();
+			/*
             String next = t.getAtomField(0).strval();
             assertTrue(last.compareTo(next)<0);
             last = next;
+			*/
+			assertTrue("last should be <= next", lastT.compareTo(t) <= 0);
+			lastT = t;
             count++;
         }
 
@@ -345,12 +365,17 @@
 
         it = bag.content();
         count = 0;
-        last= "";
+        //last= "";
+		lastT = new Tuple();
         while(it.hasNext()) {
-            Tuple t = it.next();
+            Tuple t = (Tuple)it.next();
+			/*
             String next = t.getAtomField(0).strval();
             assertTrue(last.compareTo(next)<0);
             last = next;
+			*/
+			assertTrue("last should be <= next", lastT.compareTo(t) <= 0);
+			lastT = t;
             count++;
         }
 
@@ -359,12 +384,17 @@
         //Check if it gives the correct contents the second time around
         it = bag.content();
         count = 0;
-        last= "";
+        //last= "";
+		lastT = new Tuple();
         while(it.hasNext()) {
-            Tuple t = it.next();
+            Tuple t = (Tuple)it.next();
+			/*
             String next = t.getAtomField(0).strval();
             assertTrue(last.compareTo(next)<0);
             last = next;
+			*/
+			assertTrue("last should be <= next", lastT.compareTo(t) <= 0);
+			lastT = t;
             count++;
         }
 



Mime
View raw message