You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by zs...@apache.org on 2009/03/25 00:44:54 UTC
svn commit: r758089 [8/8] - in /hadoop/hive/trunk: ./
metastore/src/java/org/apache/hadoop/hive/metastore/
ql/src/java/org/apache/hadoop/hive/ql/exec/
ql/src/java/org/apache/hadoop/hive/ql/parse/
ql/src/java/org/apache/hadoop/hive/ql/plan/ ql/src/java/...
Modified: hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java?rev=758089&r1=755033&r2=758089&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java (original)
+++ hadoop/hive/trunk/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java Tue Mar 24 23:44:50 2009
@@ -1,12 +1,9 @@
-package org.apache.hadoop.hive.ql.typeinfo;
+package org.apache.hadoop.hive.serde2.typeinfo;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
-import java.util.Map;
-import org.apache.hadoop.hive.metastore.api.FieldSchema;
-import org.apache.hadoop.hive.ql.parse.HiveParser;
import org.apache.hadoop.hive.serde.Constants;
import org.apache.hadoop.hive.serde2.objectinspector.ListObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.MapObjectInspector;
@@ -19,6 +16,175 @@
public class TypeInfoUtils {
+ /**
+ * Parse a recursive TypeInfo list String.
+ * For example, the following inputs are valid inputs:
+ * "int,string,map<string,int>,list<map<int,list<string>>>,list<struct<a:int,b:string>>"
+ * The separators between TypeInfos can be ",", ":", or ";".
+ *
+ * In order to use this class:
+ * TypeInfoParser parser = new TypeInfoParser("int,string");
+ * ArrayList<TypeInfo> typeInfos = parser.parseTypeInfos();
+ */
+ private static class TypeInfoParser {
+
+ static final String STRUCT_TYPE_NAME = "struct";
+
+ private static class Token {
+ public int position;
+ public String text;
+ public boolean isAlphaDigit;
+ };
+
+ /**
+ * Tokenize the typeInfoString.
+ * The rule is simple: all consecutive alphadigits are in one token, and all
+ * other characters are one character per token.
+ *
+ * tokenize("map<int,string>") should return ["map","<","int",",","string",">"]
+ */
+ private static ArrayList<Token> tokenize(String typeInfoString) {
+ ArrayList<Token> tokens = new ArrayList<Token>(0);
+ int begin = 0;
+ int end = 1;
+ while (end <= typeInfoString.length()) {
+ // last character ends a token?
+ if (end == typeInfoString.length()
+ || !Character.isLetterOrDigit(typeInfoString.charAt(end-1))
+ || !Character.isLetterOrDigit(typeInfoString.charAt(end))) {
+ Token t = new Token();
+ t.position = begin;
+ t.text = typeInfoString.substring(begin, end);
+ t.isAlphaDigit = Character.isLetterOrDigit(typeInfoString.charAt(begin));
+ tokens.add(t);
+ begin = end;
+ }
+ end ++;
+ }
+ return tokens;
+ }
+
+ public TypeInfoParser(String typeInfoString) {
+ this.typeInfoString = typeInfoString;
+ this.typeInfoTokens = tokenize(typeInfoString);
+ }
+
+ private String typeInfoString;
+ private ArrayList<Token> typeInfoTokens;
+ private ArrayList<TypeInfo> typeInfos;
+ private int iToken;
+
+ public ArrayList<TypeInfo> parseTypeInfos() throws IllegalArgumentException {
+ typeInfos = new ArrayList<TypeInfo>();
+ iToken = 0;
+ while (iToken < typeInfoTokens.size()) {
+ typeInfos.add(parseType());
+ if (iToken < typeInfoTokens.size()) {
+ Token separator = typeInfoTokens.get(iToken);
+ if (",".equals(separator.text) || ";".equals(separator.text) || ":".equals(separator.text)) {
+ iToken ++;
+ } else {
+ throw new IllegalArgumentException("Error: ',', ':', or ';' expected at position "
+ + separator.position + " from '" + typeInfoString + "'" );
+ }
+ }
+ }
+ return typeInfos;
+ }
+
+ private Token expect(String item) {
+ return expect(item, null);
+ }
+
+ private Token expect(String item, String alternative) {
+ if (iToken >= typeInfoTokens.size()) {
+ throw new IllegalArgumentException("Error: " + item + " expected at the end of '"
+ + typeInfoString + "'" );
+ }
+ Token t = typeInfoTokens.get(iToken);
+ if (item.equals("type")) {
+ if (!Constants.LIST_TYPE_NAME.equals(t.text)
+ && !Constants.MAP_TYPE_NAME.equals(t.text)
+ && !STRUCT_TYPE_NAME.equals(t.text)
+ && null == ObjectInspectorUtils.typeNameToClass.get(t.text)
+ && !t.text.equals(alternative)) {
+ throw new IllegalArgumentException("Error: " + item + " expected at the position "
+ + t.position + " of '" + typeInfoString + "'" );
+ }
+ } else if (item.equals("name")) {
+ if (!t.isAlphaDigit && !t.text.equals(alternative)) {
+ throw new IllegalArgumentException("Error: " + item + " expected at the position "
+ + t.position + " of '" + typeInfoString + "'" );
+ }
+ } else {
+ if (!item.equals(t.text) && !t.text.equals(alternative)) {
+ throw new IllegalArgumentException("Error: " + item + " expected at the position "
+ + t.position + " of '" + typeInfoString + "'" );
+ }
+ }
+ iToken ++;
+ return t;
+ }
+
+ private TypeInfo parseType() {
+
+ Token t = expect("type");
+
+ // Is this a primitive type?
+ Class<?> clazz = ObjectInspectorUtils.typeNameToClass.get(t.text);
+ if (clazz != null) {
+ return TypeInfoFactory.getPrimitiveTypeInfo(clazz);
+ }
+
+ // Is this a list type?
+ if (Constants.LIST_TYPE_NAME.equals(t.text)) {
+ expect("<");
+ TypeInfo listElementType = parseType();
+ expect(">");
+ return TypeInfoFactory.getListTypeInfo(listElementType);
+ }
+
+ // Is this a map type?
+ if (Constants.MAP_TYPE_NAME.equals(t.text)) {
+ expect("<");
+ TypeInfo mapKeyType = parseType();
+ expect(",");
+ TypeInfo mapValueType = parseType();
+ expect(">");
+ return TypeInfoFactory.getMapTypeInfo(mapKeyType, mapValueType);
+ }
+
+ // Is this a struct type?
+ if (STRUCT_TYPE_NAME.equals(t.text)) {
+ ArrayList<String> fieldNames = new ArrayList<String>();
+ ArrayList<TypeInfo> fieldTypeInfos = new ArrayList<TypeInfo>();
+ boolean first = true;
+ do {
+ if (first) {
+ expect("<");
+ first = false;
+ } else {
+ Token separator = expect(">", ",");
+ if (separator.text.equals(">")) {
+ // end of struct
+ break;
+ }
+ }
+ Token name = expect("name");
+ fieldNames.add(name.text);
+ expect(":");
+ fieldTypeInfos.add(parseType());
+ } while (true);
+
+ return TypeInfoFactory.getStructTypeInfo(fieldNames, fieldTypeInfos);
+ }
+
+ throw new RuntimeException("Internal error parsing position " + t.position + " of '"
+ + typeInfoString + "'");
+ }
+
+ }
+
static HashMap<TypeInfo, ObjectInspector> cachedStandardObjectInspector = new HashMap<TypeInfo, ObjectInspector>();
/**
* Returns the standard object inspector that can be used to translate an object of that typeInfo
@@ -114,23 +280,37 @@
return result;
}
- public static String getFieldSchemaTypeFromTypeInfo(TypeInfo typeInfo) {
+ /**
+ * Return the
+ */
+ public static String getTypeStringFromTypeInfo(TypeInfo typeInfo) {
switch(typeInfo.getCategory()) {
case PRIMITIVE: {
return ObjectInspectorUtils.getClassShortName(typeInfo.getPrimitiveClass());
}
case LIST: {
- String elementType = getFieldSchemaTypeFromTypeInfo(typeInfo.getListElementTypeInfo());
+ String elementType = getTypeStringFromTypeInfo(typeInfo.getListElementTypeInfo());
return org.apache.hadoop.hive.serde.Constants.LIST_TYPE_NAME + "<" + elementType + ">";
}
case MAP: {
- String keyType = getFieldSchemaTypeFromTypeInfo(typeInfo.getMapKeyTypeInfo());
- String valueType = getFieldSchemaTypeFromTypeInfo(typeInfo.getMapValueTypeInfo());
+ String keyType = getTypeStringFromTypeInfo(typeInfo.getMapKeyTypeInfo());
+ String valueType = getTypeStringFromTypeInfo(typeInfo.getMapValueTypeInfo());
return org.apache.hadoop.hive.serde.Constants.MAP_TYPE_NAME + "<" +
keyType + "," + valueType + ">";
}
case STRUCT: {
- throw new RuntimeException("Complex struct type not supported!");
+ StringBuilder sb = new StringBuilder();
+ sb.append("struct<");
+ List<String> fieldNames = typeInfo.getAllStructFieldNames();
+ List<TypeInfo> fieldTypeInfos = typeInfo.getAllStructFieldTypeInfos();
+ for (int i = 0; i < fieldNames.size(); i++) {
+ if (i>0) sb.append(",");
+ sb.append(fieldNames.get(i));
+ sb.append(":");
+ sb.append(getTypeStringFromTypeInfo(fieldTypeInfos.get(i)));
+ }
+ sb.append(">");
+ return sb.toString();
}
default: {
throw new RuntimeException("Unknown type!");
@@ -138,25 +318,13 @@
}
}
- /**
- * Convert TypeInfo to FieldSchema.
- */
- public static FieldSchema getFieldSchemaFromTypeInfo(String fieldName, TypeInfo typeInfo) {
- return new FieldSchema(
- fieldName, getFieldSchemaTypeFromTypeInfo(typeInfo), "generated by TypeInfoUtils.getFieldSchemaFromTypeInfo"
- );
+ public static ArrayList<TypeInfo> getTypeInfosFromTypeString(String typeString) {
+ TypeInfoParser parser = new TypeInfoParser(typeString);
+ return parser.parseTypeInfos();
}
-
- /**
- * Return the primitive type corresponding to the field schema
- * @param field The field schema
- * @return The TypeInfo object, or null if the field is not a primitive type.
- */
- public static TypeInfo getPrimitiveTypeInfoFromFieldSchema(FieldSchema field) {
- String type = field.getType();
-
- Class<?> c = ObjectInspectorUtils.typeNameToClass.get(type);
- return c == null ? null : TypeInfoFactory.getPrimitiveTypeInfo(c);
+ public static TypeInfo getTypeInfoFromTypeString(String typeString) {
+ TypeInfoParser parser = new TypeInfoParser(typeString);
+ return parser.parseTypeInfos().get(0);
}
}
Added: hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazyArrayMapStruct.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazyArrayMapStruct.java?rev=758089&view=auto
==============================================================================
--- hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazyArrayMapStruct.java (added)
+++ hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazyArrayMapStruct.java Tue Mar 24 23:44:50 2009
@@ -0,0 +1,196 @@
+/**
+ * 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.hadoop.hive.serde2.lazy;
+
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.hadoop.hive.serde2.SerDeUtils;
+import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoUtils;
+import org.apache.hadoop.io.Text;
+import java.util.HashMap;
+
+import junit.framework.TestCase;
+
+public class TestLazyArrayMapStruct extends TestCase {
+
+ /**
+ * Test the LazyArray class.
+ */
+ public void testLazyArray() throws Throwable {
+ try {
+ // Array of Byte
+ Text nullSequence = new Text("\\N");
+ LazyArray b = (LazyArray)LazyFactory.createLazyObject(TypeInfoUtils.getTypeInfoFromTypeString("array<tinyint>"));
+ byte[] data = new byte[]{'-', '1', 1, '\\', 'N', 1, '8'};
+ TestLazyPrimitive.initLazyObject(b, data, 0, data.length);
+
+ assertNull(b.getListElementObject(-1, (byte)1, nullSequence));
+ assertEquals(Byte.valueOf((byte)-1), b.getListElementObject(0, (byte)1, nullSequence));
+ assertNull(b.getListElementObject(1, (byte)1, nullSequence));
+ assertEquals(Byte.valueOf((byte)8), b.getListElementObject(2, (byte)1, nullSequence));
+ assertNull(b.getListElementObject(3, (byte)1, nullSequence));
+ assertEquals(Arrays.asList(new Byte[]{-1,null,8}), b.getList((byte)1, nullSequence));
+
+ // Array of String
+ b = (LazyArray)LazyFactory.createLazyObject(TypeInfoUtils.getTypeInfoFromTypeString("array<string>"));
+ data = new byte[]{'a', 'b', '\t', 'c', '\t', '\\', 'N', '\t', '\t', 'd'};
+ // Note: the first and last element of the byte[] are NOT used
+ TestLazyPrimitive.initLazyObject(b, data, 1, data.length - 2);
+ assertNull(b.getListElementObject(-1, (byte)'\t', nullSequence));
+ assertEquals("b", b.getListElementObject(0, (byte)'\t', nullSequence));
+ assertEquals("c", b.getListElementObject(1, (byte)'\t', nullSequence));
+ assertNull(b.getListElementObject(2, (byte)'\t', nullSequence));
+ assertEquals("", b.getListElementObject(3, (byte)'\t', nullSequence));
+ assertEquals("", b.getListElementObject(4, (byte)'\t', nullSequence));
+ assertNull(b.getListElementObject(5, (byte)'\t', nullSequence));
+ assertEquals(Arrays.asList(new String[]{"b", "c", null, "", ""}), b.getList((byte)'\t', nullSequence));
+
+ } catch (Throwable e) {
+ e.printStackTrace();
+ throw e;
+ }
+ }
+
+ /**
+ * Test the LazyMap class.
+ */
+ public void testLazyMap() throws Throwable {
+ try {
+ {
+ // Map of Integer to String
+ Text nullSequence = new Text("\\N");
+ LazyMap b = (LazyMap)LazyFactory.createLazyObject(TypeInfoUtils.getTypeInfoFromTypeString("map<int,string>"));
+ byte[] data = new byte[]{'2', 2, 'd', 'e', 'f', 1, '-', '1', 2, '\\', 'N', 1, '0', 2, '0', 1, '8', 2, 'a', 'b', 'c'};
+ TestLazyPrimitive.initLazyObject(b, data, 0, data.length);
+
+ assertEquals("def", b.getMapValueElement((byte)1, (byte)2, nullSequence, Integer.valueOf(2)));
+ assertNull(b.getMapValueElement((byte)1, (byte)2, nullSequence, Integer.valueOf(-1)));
+ assertEquals("0", b.getMapValueElement((byte)1, (byte)2, nullSequence, Integer.valueOf(0)));
+ assertEquals("abc", b.getMapValueElement((byte)1, (byte)2, nullSequence, Integer.valueOf(8)));
+ assertNull(b.getMapValueElement((byte)1, (byte)2, nullSequence, Integer.valueOf(12345)));
+
+ HashMap<Integer, String> r = new HashMap<Integer, String>();
+ r.put(2, "def");
+ r.put(-1, null);
+ r.put(0, "0");
+ r.put(8, "abc");
+ assertEquals(r, b.getMap((byte)1, (byte)2, nullSequence));
+ }
+
+ {
+ // Map of String to String
+ Text nullSequence = new Text("\\N");
+ LazyMap b = (LazyMap)LazyFactory.createLazyObject(TypeInfoUtils.getTypeInfoFromTypeString("map<string,string>"));
+ byte[] data = new byte[]{'2', '\t', 'd', '\t', 'f', '#', '2', '\t', 'd', '#', '-', '1', '#', '0', '\t', '0', '#', '8', '\t', 'a', 'b', 'c'};
+ TestLazyPrimitive.initLazyObject(b, data, 0, data.length);
+
+ assertEquals("d\tf", b.getMapValueElement((byte)'#', (byte)'\t', nullSequence, "2"));
+ assertNull(b.getMapValueElement((byte)'#', (byte)'\t', nullSequence, Integer.valueOf(-1)));
+ assertEquals("0", b.getMapValueElement((byte)'#', (byte)'\t', nullSequence, "0"));
+ assertEquals("abc", b.getMapValueElement((byte)'#', (byte)'\t', nullSequence, "8"));
+ assertNull(b.getMapValueElement((byte)'#', (byte)'\t', nullSequence, "-"));
+
+ HashMap<String,String> r = new HashMap<String, String>();
+ r.put("2", "d\tf");
+ r.put("-1", null);
+ r.put("0", "0");
+ r.put("8", "abc");
+ assertEquals(r, b.getMap((byte)1, (byte)2, nullSequence));
+ }
+
+ } catch (Throwable e) {
+ e.printStackTrace();
+ throw e;
+ }
+ }
+
+ /**
+ * Test the LazyStruct class.
+ */
+ public void testLazyStruct() throws Throwable {
+ try {
+ {
+ ArrayList<TypeInfo> fieldTypeInfos =
+ TypeInfoUtils.getTypeInfosFromTypeString("int,array<string>,map<string,string>,string");
+ List<String> fieldNames = Arrays.asList(new String[]{"a", "b", "c", "d"});
+ TypeInfo rowTypeInfo = TypeInfoFactory.getStructTypeInfo(fieldNames, fieldTypeInfos);
+
+ Text nullSequence = new Text("\\N");
+
+ LazyStruct o = (LazyStruct)LazyFactory.createLazyObject(rowTypeInfo);
+ ObjectInspector oi = LazyFactory.createLazyStructInspector(Arrays.asList(new String[]{"a","b","c","d"}),
+ fieldTypeInfos, new byte[] {' ', ':', '='}, nullSequence, false);
+
+ Text data;
+
+ data = new Text("123 a:b:c d=e:f=g hi");
+ TestLazyPrimitive.initLazyObject(o, data.getBytes(), 0, data.getLength());
+ assertEquals("{'a':123,'b':['a','b','c'],'c':{'f':'g','d':'e'},'d':'hi'}".replace("'", "\""),
+ SerDeUtils.getJSONString(o, oi));
+
+ data = new Text("123 \\N d=e:f=g \\N");
+ TestLazyPrimitive.initLazyObject(o, data.getBytes(), 0, data.getLength());
+ assertEquals("{'a':123,'b':null,'c':{'f':'g','d':'e'},'d':null}".replace("'", "\""),
+ SerDeUtils.getJSONString(o, oi));
+
+ data = new Text("\\N a d=\\N:f=g:h no tail");
+ TestLazyPrimitive.initLazyObject(o, data.getBytes(), 0, data.getLength());
+ assertEquals("{'a':null,'b':['a'],'c':{'f':'g','d':null,'h':null},'d':'no'}".replace("'", "\""),
+ SerDeUtils.getJSONString(o, oi));
+
+ data = new Text("\\N :a:: \\N no tail");
+ TestLazyPrimitive.initLazyObject(o, data.getBytes(), 0, data.getLength());
+ assertEquals("{'a':null,'b':['','a','',''],'c':null,'d':'no'}".replace("'", "\""),
+ SerDeUtils.getJSONString(o, oi));
+
+ data = new Text("123 ");
+ TestLazyPrimitive.initLazyObject(o, data.getBytes(), 0, data.getLength());
+ assertEquals("{'a':123,'b':[],'c':{},'d':''}".replace("'", "\""),
+ SerDeUtils.getJSONString(o, oi));
+
+ data = new Text(": : : :");
+ TestLazyPrimitive.initLazyObject(o, data.getBytes(), 0, data.getLength());
+ assertEquals("{'a':null,'b':['',''],'c':{'':null},'d':':'}".replace("'", "\""),
+ SerDeUtils.getJSONString(o, oi));
+
+ data = new Text("= = = =");
+ TestLazyPrimitive.initLazyObject(o, data.getBytes(), 0, data.getLength());
+ assertEquals("{'a':null,'b':['='],'c':{'':''},'d':'='}".replace("'", "\""),
+ SerDeUtils.getJSONString(o, oi));
+
+ // test LastColumnTakesRest
+ oi = LazyFactory.createLazyStructInspector(Arrays.asList(new String[]{"a","b","c","d"}),
+ fieldTypeInfos, new byte[] {' ', ':', '='}, nullSequence, true);
+ data = new Text("\\N a d=\\N:f=g:h has tail");
+ TestLazyPrimitive.initLazyObject(o, data.getBytes(), 0, data.getLength());
+ assertEquals("{'a':null,'b':['a'],'c':{'f':'g','d':null,'h':null},'d':'has tail'}".replace("'", "\""),
+ SerDeUtils.getJSONString(o, oi));
+ }
+ } catch (Throwable e) {
+ e.printStackTrace();
+ throw e;
+ }
+ }
+
+}
Modified: hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazyPrimitive.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazyPrimitive.java?rev=758089&r1=758088&r2=758089&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazyPrimitive.java (original)
+++ hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazyPrimitive.java Tue Mar 24 23:44:50 2009
@@ -23,38 +23,48 @@
public class TestLazyPrimitive extends TestCase {
/**
+ * Initialize the LazyObject with the parameters, wrapping the byte[] automatically.
+ */
+ public static void initLazyObject(LazyObject lo, byte[] data, int start, int length) {
+ ByteArrayRef b = new ByteArrayRef();
+ b.setData(data);
+ lo.init(b, start, length);
+ }
+ /**
* Test the LazyByte class.
*/
public void testLazyByte() throws Throwable {
try {
LazyByte b = new LazyByte();
- b.setAll(new byte[]{'0'}, 0, 1);
- assertEquals(Byte.valueOf((byte)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '0'}, 0, 2);
- assertEquals(Byte.valueOf((byte)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '0'}, 0, 2);
- assertEquals(Byte.valueOf((byte)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '1', 'b'}, 1, 1);
- assertEquals(Byte.valueOf((byte)1), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '-', '1'}, 1, 2);
- assertEquals(Byte.valueOf((byte)-1), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '+', '1'}, 1, 2);
- assertEquals(Byte.valueOf((byte)1), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', '2', '8'}, 0, 4);
- assertEquals(Byte.valueOf((byte)-128), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', '2', '7'}, 0, 4);
- assertEquals(Byte.valueOf((byte)127), b.getPrimitiveObject());
+ initLazyObject(b,new byte[]{'0'}, 0, 0);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'0'}, 0, 1);
+ assertEquals(Byte.valueOf((byte)0), b.getObject());
+ initLazyObject(b,new byte[]{'+', '0'}, 0, 2);
+ assertEquals(Byte.valueOf((byte)0), b.getObject());
+ initLazyObject(b,new byte[]{'-', '0'}, 0, 2);
+ assertEquals(Byte.valueOf((byte)0), b.getObject());
+ initLazyObject(b,new byte[]{'a', '1', 'b'}, 1, 1);
+ assertEquals(Byte.valueOf((byte)1), b.getObject());
+ initLazyObject(b,new byte[]{'a', '-', '1'}, 1, 2);
+ assertEquals(Byte.valueOf((byte)-1), b.getObject());
+ initLazyObject(b,new byte[]{'a', '+', '1'}, 1, 2);
+ assertEquals(Byte.valueOf((byte)1), b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', '2', '8'}, 0, 4);
+ assertEquals(Byte.valueOf((byte)-128), b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', '2', '7'}, 0, 4);
+ assertEquals(Byte.valueOf((byte)127), b.getObject());
- b.setAll(new byte[]{'a', '1', 'b'}, 1, 2);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', '2', '8'}, 0, 4);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', '2', '9'}, 0, 4);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', '2', '3'}, 0, 1);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', '2', '3'}, 0, 1);
- assertNull(b.getPrimitiveObject());
+ initLazyObject(b,new byte[]{'a', '1', 'b'}, 1, 2);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', '2', '8'}, 0, 4);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', '2', '9'}, 0, 4);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', '2', '3'}, 0, 1);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', '2', '3'}, 0, 1);
+ assertNull(b.getObject());
} catch (Throwable e) {
e.printStackTrace();
@@ -68,37 +78,39 @@
public void testLazyShort() throws Throwable {
try {
LazyShort b = new LazyShort();
- b.setAll(new byte[]{'0'}, 0, 1);
- assertEquals(Short.valueOf((short)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '0'}, 0, 2);
- assertEquals(Short.valueOf((short)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '0'}, 0, 2);
- assertEquals(Short.valueOf((short)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '1', 'b'}, 1, 1);
- assertEquals(Short.valueOf((short)1), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '-', '1'}, 1, 2);
- assertEquals(Short.valueOf((short)-1), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '+', '1'}, 1, 2);
- assertEquals(Short.valueOf((short)1), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', '2', '8'}, 0, 4);
- assertEquals(Short.valueOf((short)-128), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', '2', '7'}, 0, 4);
- assertEquals(Short.valueOf((short)127), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '3', '2', '7', '6', '8'}, 0, 6);
- assertEquals(Short.valueOf((short)-32768), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '3', '2', '7', '6', '7'}, 0, 6);
- assertEquals(Short.valueOf((short)32767), b.getPrimitiveObject());
-
- b.setAll(new byte[]{'a', '1', 'b'}, 1, 2);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '3', '2', '7', '6', '9'}, 0, 6);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '3', '2', '7', '6', '8'}, 0, 6);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', '2', '3'}, 0, 1);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', '2', '3'}, 0, 1);
- assertNull(b.getPrimitiveObject());
+ initLazyObject(b,new byte[]{'0'}, 0, 0);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'0'}, 0, 1);
+ assertEquals(Short.valueOf((short)0), b.getObject());
+ initLazyObject(b,new byte[]{'+', '0'}, 0, 2);
+ assertEquals(Short.valueOf((short)0), b.getObject());
+ initLazyObject(b,new byte[]{'-', '0'}, 0, 2);
+ assertEquals(Short.valueOf((short)0), b.getObject());
+ initLazyObject(b,new byte[]{'a', '1', 'b'}, 1, 1);
+ assertEquals(Short.valueOf((short)1), b.getObject());
+ initLazyObject(b,new byte[]{'a', '-', '1'}, 1, 2);
+ assertEquals(Short.valueOf((short)-1), b.getObject());
+ initLazyObject(b,new byte[]{'a', '+', '1'}, 1, 2);
+ assertEquals(Short.valueOf((short)1), b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', '2', '8'}, 0, 4);
+ assertEquals(Short.valueOf((short)-128), b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', '2', '7'}, 0, 4);
+ assertEquals(Short.valueOf((short)127), b.getObject());
+ initLazyObject(b,new byte[]{'-', '3', '2', '7', '6', '8'}, 0, 6);
+ assertEquals(Short.valueOf((short)-32768), b.getObject());
+ initLazyObject(b,new byte[]{'+', '3', '2', '7', '6', '7'}, 0, 6);
+ assertEquals(Short.valueOf((short)32767), b.getObject());
+
+ initLazyObject(b,new byte[]{'a', '1', 'b'}, 1, 2);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'-', '3', '2', '7', '6', '9'}, 0, 6);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'+', '3', '2', '7', '6', '8'}, 0, 6);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', '2', '3'}, 0, 1);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', '2', '3'}, 0, 1);
+ assertNull(b.getObject());
} catch (Throwable e) {
e.printStackTrace();
@@ -113,41 +125,43 @@
public void testLazyInteger() throws Throwable {
try {
LazyInteger b = new LazyInteger();
- b.setAll(new byte[]{'0'}, 0, 1);
- assertEquals(Integer.valueOf((int)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '0'}, 0, 2);
- assertEquals(Integer.valueOf((int)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '0'}, 0, 2);
- assertEquals(Integer.valueOf((int)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '1', 'b'}, 1, 1);
- assertEquals(Integer.valueOf((int)1), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '-', '1'}, 1, 2);
- assertEquals(Integer.valueOf((int)-1), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '+', '1'}, 1, 2);
- assertEquals(Integer.valueOf((int)1), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', '2', '8'}, 0, 4);
- assertEquals(Integer.valueOf((int)-128), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', '2', '7'}, 0, 4);
- assertEquals(Integer.valueOf((int)127), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '3', '2', '7', '6', '8'}, 0, 6);
- assertEquals(Integer.valueOf((int)-32768), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '3', '2', '7', '6', '7'}, 0, 6);
- assertEquals(Integer.valueOf((int)32767), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '2', '1', '4', '7', '4', '8', '3', '6', '4', '8'}, 0, 11);
- assertEquals(Integer.valueOf((int)-2147483648), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '2', '1', '4', '7', '4', '8', '3', '6', '4', '7'}, 0, 11);
- assertEquals(Integer.valueOf((int)2147483647), b.getPrimitiveObject());
-
- b.setAll(new byte[]{'a', '1', 'b'}, 1, 2);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '2', '1', '4', '7', '4', '8', '3', '6', '4', '9'}, 0, 11);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '2', '1', '4', '7', '4', '8', '3', '6', '4', '8'}, 0, 11);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', '2', '3'}, 0, 1);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', '2', '3'}, 0, 1);
- assertNull(b.getPrimitiveObject());
+ initLazyObject(b,new byte[]{'0'}, 0, 0);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'0'}, 0, 1);
+ assertEquals(Integer.valueOf((int)0), b.getObject());
+ initLazyObject(b,new byte[]{'+', '0'}, 0, 2);
+ assertEquals(Integer.valueOf((int)0), b.getObject());
+ initLazyObject(b,new byte[]{'-', '0'}, 0, 2);
+ assertEquals(Integer.valueOf((int)0), b.getObject());
+ initLazyObject(b,new byte[]{'a', '1', 'b'}, 1, 1);
+ assertEquals(Integer.valueOf((int)1), b.getObject());
+ initLazyObject(b,new byte[]{'a', '-', '1'}, 1, 2);
+ assertEquals(Integer.valueOf((int)-1), b.getObject());
+ initLazyObject(b,new byte[]{'a', '+', '1'}, 1, 2);
+ assertEquals(Integer.valueOf((int)1), b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', '2', '8'}, 0, 4);
+ assertEquals(Integer.valueOf((int)-128), b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', '2', '7'}, 0, 4);
+ assertEquals(Integer.valueOf((int)127), b.getObject());
+ initLazyObject(b,new byte[]{'-', '3', '2', '7', '6', '8'}, 0, 6);
+ assertEquals(Integer.valueOf((int)-32768), b.getObject());
+ initLazyObject(b,new byte[]{'+', '3', '2', '7', '6', '7'}, 0, 6);
+ assertEquals(Integer.valueOf((int)32767), b.getObject());
+ initLazyObject(b,new byte[]{'-', '2', '1', '4', '7', '4', '8', '3', '6', '4', '8'}, 0, 11);
+ assertEquals(Integer.valueOf((int)-2147483648), b.getObject());
+ initLazyObject(b,new byte[]{'+', '2', '1', '4', '7', '4', '8', '3', '6', '4', '7'}, 0, 11);
+ assertEquals(Integer.valueOf((int)2147483647), b.getObject());
+
+ initLazyObject(b,new byte[]{'a', '1', 'b'}, 1, 2);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'-', '2', '1', '4', '7', '4', '8', '3', '6', '4', '9'}, 0, 11);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'+', '2', '1', '4', '7', '4', '8', '3', '6', '4', '8'}, 0, 11);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', '2', '3'}, 0, 1);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', '2', '3'}, 0, 1);
+ assertNull(b.getObject());
} catch (Throwable e) {
e.printStackTrace();
@@ -162,49 +176,51 @@
public void testLazyLong() throws Throwable {
try {
LazyLong b = new LazyLong();
- b.setAll(new byte[]{'0'}, 0, 1);
- assertEquals(Long.valueOf((long)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '0'}, 0, 2);
- assertEquals(Long.valueOf((long)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '0'}, 0, 2);
- assertEquals(Long.valueOf((long)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '1', 'b'}, 1, 1);
- assertEquals(Long.valueOf((long)1), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '-', '1'}, 1, 2);
- assertEquals(Long.valueOf((long)-1), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '+', '1'}, 1, 2);
- assertEquals(Long.valueOf((long)1), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', '2', '8'}, 0, 4);
- assertEquals(Long.valueOf((long)-128), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', '2', '7'}, 0, 4);
- assertEquals(Long.valueOf((long)127), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '3', '2', '7', '6', '8'}, 0, 6);
- assertEquals(Long.valueOf((long)-32768), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '3', '2', '7', '6', '7'}, 0, 6);
- assertEquals(Long.valueOf((long)32767), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '2', '1', '4', '7', '4', '8', '3', '6', '4', '8'}, 0, 11);
- assertEquals(Long.valueOf((long)-2147483648), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '2', '1', '4', '7', '4', '8', '3', '6', '4', '7'}, 0, 11);
- assertEquals(Long.valueOf((long)2147483647), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
+ initLazyObject(b,new byte[]{'0'}, 0, 0);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'0'}, 0, 1);
+ assertEquals(Long.valueOf((long)0), b.getObject());
+ initLazyObject(b,new byte[]{'+', '0'}, 0, 2);
+ assertEquals(Long.valueOf((long)0), b.getObject());
+ initLazyObject(b,new byte[]{'-', '0'}, 0, 2);
+ assertEquals(Long.valueOf((long)0), b.getObject());
+ initLazyObject(b,new byte[]{'a', '1', 'b'}, 1, 1);
+ assertEquals(Long.valueOf((long)1), b.getObject());
+ initLazyObject(b,new byte[]{'a', '-', '1'}, 1, 2);
+ assertEquals(Long.valueOf((long)-1), b.getObject());
+ initLazyObject(b,new byte[]{'a', '+', '1'}, 1, 2);
+ assertEquals(Long.valueOf((long)1), b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', '2', '8'}, 0, 4);
+ assertEquals(Long.valueOf((long)-128), b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', '2', '7'}, 0, 4);
+ assertEquals(Long.valueOf((long)127), b.getObject());
+ initLazyObject(b,new byte[]{'-', '3', '2', '7', '6', '8'}, 0, 6);
+ assertEquals(Long.valueOf((long)-32768), b.getObject());
+ initLazyObject(b,new byte[]{'+', '3', '2', '7', '6', '7'}, 0, 6);
+ assertEquals(Long.valueOf((long)32767), b.getObject());
+ initLazyObject(b,new byte[]{'-', '2', '1', '4', '7', '4', '8', '3', '6', '4', '8'}, 0, 11);
+ assertEquals(Long.valueOf((long)-2147483648), b.getObject());
+ initLazyObject(b,new byte[]{'+', '2', '1', '4', '7', '4', '8', '3', '6', '4', '7'}, 0, 11);
+ assertEquals(Long.valueOf((long)2147483647), b.getObject());
+ initLazyObject(b,new byte[]{'-', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
'4', '7', '7', '5', '8', '0', '8'}, 0, 20);
- assertEquals(Long.valueOf((long)-9223372036854775808L), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
+ assertEquals(Long.valueOf((long)-9223372036854775808L), b.getObject());
+ initLazyObject(b,new byte[]{'+', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
'4', '7', '7', '5', '8', '0', '7'}, 0, 20);
- assertEquals(Long.valueOf((long)9223372036854775807L), b.getPrimitiveObject());
+ assertEquals(Long.valueOf((long)9223372036854775807L), b.getObject());
- b.setAll(new byte[]{'a', '1', 'b'}, 1, 2);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
+ initLazyObject(b,new byte[]{'a', '1', 'b'}, 1, 2);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'-', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
'4', '7', '7', '5', '8', '0', '9'}, 0, 20);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'+', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
'4', '7', '7', '5', '8', '0', '8'}, 0, 20);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', '2', '3'}, 0, 1);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', '2', '3'}, 0, 1);
- assertNull(b.getPrimitiveObject());
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', '2', '3'}, 0, 1);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', '2', '3'}, 0, 1);
+ assertNull(b.getObject());
} catch (Throwable e) {
e.printStackTrace();
@@ -218,78 +234,80 @@
public void testLazyDouble() throws Throwable {
try {
LazyDouble b = new LazyDouble();
- b.setAll(new byte[]{'0'}, 0, 1);
- assertEquals(Double.valueOf((double)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '0'}, 0, 2);
- assertEquals(Double.valueOf((double)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '0'}, 0, 2);
- assertEquals(Double.valueOf((double)-0.0), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '1', 'b'}, 1, 1);
- assertEquals(Double.valueOf((double)1), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '-', '1'}, 1, 2);
- assertEquals(Double.valueOf((double)-1), b.getPrimitiveObject());
- b.setAll(new byte[]{'a', '+', '1'}, 1, 2);
- assertEquals(Double.valueOf((double)1), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', '2', '8'}, 0, 4);
- assertEquals(Double.valueOf((double)-128), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', '2', '7'}, 0, 4);
- assertEquals(Double.valueOf((double)127), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '3', '2', '7', '6', '8'}, 0, 6);
- assertEquals(Double.valueOf((double)-32768), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '3', '2', '7', '6', '7'}, 0, 6);
- assertEquals(Double.valueOf((double)32767), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '2', '1', '4', '7', '4', '8', '3', '6', '4', '8'}, 0, 11);
- assertEquals(Double.valueOf((double)-2147483648), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '2', '1', '4', '7', '4', '8', '3', '6', '4', '7'}, 0, 11);
- assertEquals(Double.valueOf((double)2147483647), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
+ initLazyObject(b,new byte[]{'0'}, 0, 0);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'0'}, 0, 1);
+ assertEquals(Double.valueOf((double)0), b.getObject());
+ initLazyObject(b,new byte[]{'+', '0'}, 0, 2);
+ assertEquals(Double.valueOf((double)0), b.getObject());
+ initLazyObject(b,new byte[]{'-', '0'}, 0, 2);
+ assertEquals(Double.valueOf((double)-0.0), b.getObject());
+ initLazyObject(b,new byte[]{'a', '1', 'b'}, 1, 1);
+ assertEquals(Double.valueOf((double)1), b.getObject());
+ initLazyObject(b,new byte[]{'a', '-', '1'}, 1, 2);
+ assertEquals(Double.valueOf((double)-1), b.getObject());
+ initLazyObject(b,new byte[]{'a', '+', '1'}, 1, 2);
+ assertEquals(Double.valueOf((double)1), b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', '2', '8'}, 0, 4);
+ assertEquals(Double.valueOf((double)-128), b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', '2', '7'}, 0, 4);
+ assertEquals(Double.valueOf((double)127), b.getObject());
+ initLazyObject(b,new byte[]{'-', '3', '2', '7', '6', '8'}, 0, 6);
+ assertEquals(Double.valueOf((double)-32768), b.getObject());
+ initLazyObject(b,new byte[]{'+', '3', '2', '7', '6', '7'}, 0, 6);
+ assertEquals(Double.valueOf((double)32767), b.getObject());
+ initLazyObject(b,new byte[]{'-', '2', '1', '4', '7', '4', '8', '3', '6', '4', '8'}, 0, 11);
+ assertEquals(Double.valueOf((double)-2147483648), b.getObject());
+ initLazyObject(b,new byte[]{'+', '2', '1', '4', '7', '4', '8', '3', '6', '4', '7'}, 0, 11);
+ assertEquals(Double.valueOf((double)2147483647), b.getObject());
+ initLazyObject(b,new byte[]{'-', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
'4', '7', '7', '5', '8', '0', '8'}, 0, 20);
- assertEquals(Double.valueOf((double)-9223372036854775808L), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
+ assertEquals(Double.valueOf((double)-9223372036854775808L), b.getObject());
+ initLazyObject(b,new byte[]{'+', '9', '2', '2', '3', '3', '7', '2', '0', '3', '6', '8', '5',
'4', '7', '7', '5', '8', '0', '7'}, 0, 20);
- assertEquals(Double.valueOf((long)9223372036854775807L), b.getPrimitiveObject());
+ assertEquals(Double.valueOf((long)9223372036854775807L), b.getObject());
- b.setAll(new byte[]{'-', '3', '.', '7', '6', '8'}, 0, 6);
- assertEquals(Double.valueOf((double)-3.768), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '3', '.', '7', '6', '7'}, 0, 6);
- assertEquals(Double.valueOf((double)3.767), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '2', '.', '4', '7', '4', '8', '3', '6', 'e', '8'}, 0, 11);
- assertEquals(Double.valueOf((double)-2.474836e8), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '2', '.', '4', '7', '4', '8', '3', 'E', '-', '7'}, 0, 11);
- assertEquals(Double.valueOf((double)2.47483E-7), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '.', '4', '7', '4', '8', '3', '6', 'e', '8'}, 0, 10);
- assertEquals(Double.valueOf((double)-.474836e8), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '.', '4', '7', '4', '8', '3', 'E', '-', '7'}, 0, 10);
- assertEquals(Double.valueOf((double).47483E-7), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '2', '1', '4', '7', '4', '8', '3', '6', '4', '.'}, 0, 11);
- assertEquals(Double.valueOf((double)-214748364.), b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '2', '1', '4', '7', '4', '8', '3', '6', '4', '.'}, 0, 11);
- assertEquals(Double.valueOf((double)+214748364.), b.getPrimitiveObject());
-
- b.setAll(new byte[]{'.', '0'}, 0, 2);
- assertEquals(Double.valueOf((double).0), b.getPrimitiveObject());
- b.setAll(new byte[]{'0', '.'}, 0, 2);
- assertEquals(Double.valueOf((double)0.), b.getPrimitiveObject());
+ initLazyObject(b,new byte[]{'-', '3', '.', '7', '6', '8'}, 0, 6);
+ assertEquals(Double.valueOf((double)-3.768), b.getObject());
+ initLazyObject(b,new byte[]{'+', '3', '.', '7', '6', '7'}, 0, 6);
+ assertEquals(Double.valueOf((double)3.767), b.getObject());
+ initLazyObject(b,new byte[]{'-', '2', '.', '4', '7', '4', '8', '3', '6', 'e', '8'}, 0, 11);
+ assertEquals(Double.valueOf((double)-2.474836e8), b.getObject());
+ initLazyObject(b,new byte[]{'+', '2', '.', '4', '7', '4', '8', '3', 'E', '-', '7'}, 0, 11);
+ assertEquals(Double.valueOf((double)2.47483E-7), b.getObject());
+ initLazyObject(b,new byte[]{'-', '.', '4', '7', '4', '8', '3', '6', 'e', '8'}, 0, 10);
+ assertEquals(Double.valueOf((double)-.474836e8), b.getObject());
+ initLazyObject(b,new byte[]{'+', '.', '4', '7', '4', '8', '3', 'E', '-', '7'}, 0, 10);
+ assertEquals(Double.valueOf((double).47483E-7), b.getObject());
+ initLazyObject(b,new byte[]{'-', '2', '1', '4', '7', '4', '8', '3', '6', '4', '.'}, 0, 11);
+ assertEquals(Double.valueOf((double)-214748364.), b.getObject());
+ initLazyObject(b,new byte[]{'+', '2', '1', '4', '7', '4', '8', '3', '6', '4', '.'}, 0, 11);
+ assertEquals(Double.valueOf((double)+214748364.), b.getObject());
+
+ initLazyObject(b,new byte[]{'.', '0'}, 0, 2);
+ assertEquals(Double.valueOf((double).0), b.getObject());
+ initLazyObject(b,new byte[]{'0', '.'}, 0, 2);
+ assertEquals(Double.valueOf((double)0.), b.getObject());
- b.setAll(new byte[]{'a', '1', 'b'}, 1, 2);
- assertNull(b.getPrimitiveObject());
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'.', '1', '2', '3'}, 0, 1);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', '2', '3'}, 0, 1);
- assertNull(b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', '2', '3'}, 0, 1);
- assertNull(b.getPrimitiveObject());
+ initLazyObject(b,new byte[]{'a', '1', 'b'}, 1, 2);
+ assertNull(b.getObject());
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'.', '1', '2', '3'}, 0, 1);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', '2', '3'}, 0, 1);
+ assertNull(b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', '2', '3'}, 0, 1);
+ assertNull(b.getObject());
- b.setAll(new byte[]{'-', '1', 'e', '3', '3', '3', '3', '3', '3'}, 0, 9);
- assertEquals(Double.NEGATIVE_INFINITY, b.getPrimitiveObject());
- b.setAll(new byte[]{'+', '1', 'e', '3', '3', '3', '3', '3', '3'}, 0, 9);
- assertEquals(Double.POSITIVE_INFINITY, b.getPrimitiveObject());
-
- b.setAll(new byte[]{'+', '1', 'e', '-', '3', '3', '3', '3', '3'}, 0, 8);
- assertEquals(Double.valueOf((double)0), b.getPrimitiveObject());
- b.setAll(new byte[]{'-', '1', 'e', '-', '3', '3', '3', '3', '3'}, 0, 8);
- assertEquals(Double.valueOf((double)-0.0), b.getPrimitiveObject());
+ initLazyObject(b,new byte[]{'-', '1', 'e', '3', '3', '3', '3', '3', '3'}, 0, 9);
+ assertEquals(Double.NEGATIVE_INFINITY, b.getObject());
+ initLazyObject(b,new byte[]{'+', '1', 'e', '3', '3', '3', '3', '3', '3'}, 0, 9);
+ assertEquals(Double.POSITIVE_INFINITY, b.getObject());
+
+ initLazyObject(b,new byte[]{'+', '1', 'e', '-', '3', '3', '3', '3', '3'}, 0, 8);
+ assertEquals(Double.valueOf((double)0), b.getObject());
+ initLazyObject(b,new byte[]{'-', '1', 'e', '-', '3', '3', '3', '3', '3'}, 0, 8);
+ assertEquals(Double.valueOf((double)-0.0), b.getObject());
} catch (Throwable e) {
e.printStackTrace();
@@ -303,10 +321,12 @@
public void testLazyString() throws Throwable {
try {
LazyString b = new LazyString();
- b.setAll(new byte[]{'0'}, 0, 1);
- assertEquals("0", b.getPrimitiveObject());
- b.setAll(new byte[]{'0', '1', '2'}, 1, 1);
- assertEquals("1", b.getPrimitiveObject());
+ initLazyObject(b,new byte[]{'0'}, 0, 0);
+ assertEquals("", b.getObject());
+ initLazyObject(b,new byte[]{'0'}, 0, 1);
+ assertEquals("0", b.getObject());
+ initLazyObject(b,new byte[]{'0', '1', '2'}, 1, 1);
+ assertEquals("1", b.getObject());
} catch (Throwable e) {
e.printStackTrace();
Modified: hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazySimpleSerDe.java
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazySimpleSerDe.java?rev=758089&r1=758088&r2=758089&view=diff
==============================================================================
--- hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazySimpleSerDe.java (original)
+++ hadoop/hive/trunk/serde/src/test/org/apache/hadoop/hive/serde2/lazy/TestLazySimpleSerDe.java Tue Mar 24 23:44:50 2009
@@ -183,5 +183,4 @@
}
}
-
}