| /** |
| * 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.record; |
| |
| import java.io.IOException; |
| import junit.framework.*; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.util.ArrayList; |
| import java.util.TreeMap; |
| import org.apache.hadoop.record.meta.RecordTypeInfo; |
| |
| /** |
| */ |
| public class TestRecordVersioning extends TestCase { |
| |
| public TestRecordVersioning(String testName) { |
| super(testName); |
| } |
| |
| protected void setUp() throws Exception { |
| } |
| |
| protected void tearDown() throws Exception { |
| } |
| |
| /* |
| * basic versioning |
| * write out a record and its type info, read it back using its typeinfo |
| */ |
| public void testBasic() { |
| File tmpfile, tmpRTIfile; |
| try { |
| tmpfile = File.createTempFile("hadooprec", ".dat"); |
| tmpRTIfile = File.createTempFile("hadooprti", ".dat"); |
| FileOutputStream ostream = new FileOutputStream(tmpfile); |
| BinaryRecordOutput out = new BinaryRecordOutput(ostream); |
| FileOutputStream oRTIstream = new FileOutputStream(tmpRTIfile); |
| BinaryRecordOutput outRTI = new BinaryRecordOutput(oRTIstream); |
| RecRecord1 r1 = new RecRecord1(); |
| r1.setBoolVal(true); |
| r1.setByteVal((byte)0x66); |
| r1.setFloatVal(3.145F); |
| r1.setDoubleVal(1.5234); |
| r1.setIntVal(-4567); |
| r1.setLongVal(-2367L); |
| r1.setStringVal("random text"); |
| r1.setBufferVal(new Buffer()); |
| r1.setVectorVal(new ArrayList<String>()); |
| r1.setMapVal(new TreeMap<String,String>()); |
| RecRecord0 r0 = new RecRecord0(); |
| r0.setStringVal("other random text"); |
| r1.setRecordVal(r0); |
| r1.serialize(out, ""); |
| ostream.close(); |
| // write out the type info |
| RecRecord1.getTypeInfo().serialize(outRTI); |
| oRTIstream.close(); |
| |
| // read |
| FileInputStream istream = new FileInputStream(tmpfile); |
| BinaryRecordInput in = new BinaryRecordInput(istream); |
| FileInputStream iRTIstream = new FileInputStream(tmpRTIfile); |
| BinaryRecordInput inRTI = new BinaryRecordInput(iRTIstream); |
| RecordTypeInfo rti = new RecordTypeInfo(); |
| rti.deserialize(inRTI); |
| iRTIstream.close(); |
| RecRecord1.setTypeFilter(rti); |
| RecRecord1 r2 = new RecRecord1(); |
| r2.deserialize(in, ""); |
| istream.close(); |
| tmpfile.delete(); |
| tmpRTIfile.delete(); |
| assertTrue("Serialized and deserialized versioned records do not match.", r1.equals(r2)); |
| } catch (IOException ex) { |
| ex.printStackTrace(); |
| } |
| } |
| |
| /* |
| * versioning |
| * write out a record and its type info, read back a similar record using the written record's typeinfo |
| */ |
| public void testVersioning() { |
| File tmpfile, tmpRTIfile; |
| try { |
| tmpfile = File.createTempFile("hadooprec", ".dat"); |
| tmpRTIfile = File.createTempFile("hadooprti", ".dat"); |
| FileOutputStream ostream = new FileOutputStream(tmpfile); |
| BinaryRecordOutput out = new BinaryRecordOutput(ostream); |
| FileOutputStream oRTIstream = new FileOutputStream(tmpRTIfile); |
| BinaryRecordOutput outRTI = new BinaryRecordOutput(oRTIstream); |
| |
| // we create an array of records to write |
| ArrayList<RecRecordOld> recsWrite = new ArrayList<RecRecordOld>(); |
| int i, j, k, l; |
| for (i=0; i<5; i++) { |
| RecRecordOld s1Rec = new RecRecordOld(); |
| |
| s1Rec.setName("This is record s1: " + i); |
| |
| ArrayList<Long> iA = new ArrayList<Long>(); |
| for (j=0; j<3; j++) { |
| iA.add(new Long(i+j)); |
| } |
| s1Rec.setIvec(iA); |
| |
| ArrayList<ArrayList<RecRecord0>> ssVec = new ArrayList<ArrayList<RecRecord0>>(); |
| for (j=0; j<2; j++) { |
| ArrayList<RecRecord0> sVec = new ArrayList<RecRecord0>(); |
| for (k=0; k<3; k++) { |
| RecRecord0 sRec = new RecRecord0("This is record s: ("+j+": "+k+")"); |
| sVec.add(sRec); |
| } |
| ssVec.add(sVec); |
| } |
| s1Rec.setSvec(ssVec); |
| |
| s1Rec.setInner(new RecRecord0("This is record s: " + i)); |
| |
| ArrayList<ArrayList<ArrayList<String>>> aaaVec = new ArrayList<ArrayList<ArrayList<String>>>(); |
| for (l=0; l<2; l++) { |
| ArrayList<ArrayList<String>> aaVec = new ArrayList<ArrayList<String>>(); |
| for (j=0; j<2; j++) { |
| ArrayList<String> aVec = new ArrayList<String>(); |
| for (k=0; k<3; k++) { |
| aVec.add(new String("THis is a nested string: (" + l + ": " + j + ": " + k + ")")); |
| } |
| aaVec.add(aVec); |
| } |
| aaaVec.add(aaVec); |
| } |
| s1Rec.setStrvec(aaaVec); |
| |
| s1Rec.setI1(100+i); |
| |
| java.util.TreeMap<Byte,String> map1 = new java.util.TreeMap<Byte,String>(); |
| map1.put(new Byte("23"), "23"); |
| map1.put(new Byte("11"), "11"); |
| s1Rec.setMap1(map1); |
| |
| java.util.TreeMap<Integer,Long> m1 = new java.util.TreeMap<Integer,Long>(); |
| java.util.TreeMap<Integer,Long> m2 = new java.util.TreeMap<Integer,Long>(); |
| m1.put(new Integer(5), 5L); |
| m1.put(new Integer(10), 10L); |
| m2.put(new Integer(15), 15L); |
| m2.put(new Integer(20), 20L); |
| java.util.ArrayList<java.util.TreeMap<Integer,Long>> vm1 = new java.util.ArrayList<java.util.TreeMap<Integer,Long>>(); |
| vm1.add(m1); |
| vm1.add(m2); |
| s1Rec.setMvec1(vm1); |
| java.util.ArrayList<java.util.TreeMap<Integer,Long>> vm2 = new java.util.ArrayList<java.util.TreeMap<Integer,Long>>(); |
| vm2.add(m1); |
| s1Rec.setMvec2(vm2); |
| |
| // add to our list |
| recsWrite.add(s1Rec); |
| } |
| |
| // write out to file |
| for (RecRecordOld rec: recsWrite) { |
| rec.serialize(out); |
| } |
| ostream.close(); |
| // write out the type info |
| RecRecordOld.getTypeInfo().serialize(outRTI); |
| oRTIstream.close(); |
| |
| // read |
| FileInputStream istream = new FileInputStream(tmpfile); |
| BinaryRecordInput in = new BinaryRecordInput(istream); |
| FileInputStream iRTIstream = new FileInputStream(tmpRTIfile); |
| BinaryRecordInput inRTI = new BinaryRecordInput(iRTIstream); |
| RecordTypeInfo rti = new RecordTypeInfo(); |
| |
| // read type info |
| rti.deserialize(inRTI); |
| iRTIstream.close(); |
| RecRecordNew.setTypeFilter(rti); |
| |
| // read records |
| ArrayList<RecRecordNew> recsRead = new ArrayList<RecRecordNew>(); |
| for (i=0; i<recsWrite.size(); i++) { |
| RecRecordNew s2Rec = new RecRecordNew(); |
| s2Rec.deserialize(in); |
| recsRead.add(s2Rec); |
| } |
| istream.close(); |
| tmpfile.delete(); |
| tmpRTIfile.delete(); |
| |
| // compare |
| for (i=0; i<recsRead.size(); i++) { |
| RecRecordOld s1Out = recsWrite.get(i); |
| RecRecordNew s2In = recsRead.get(i); |
| assertTrue("Incorrectly read name2 field", null == s2In.getName2()); |
| assertTrue("Error comparing inner fields", (0 == s1Out.getInner().compareTo(s2In.getInner()))); |
| assertTrue("Incorrectly read ivec field", null == s2In.getIvec()); |
| assertTrue("Incorrectly read svec field", null == s2In.getSvec()); |
| for (j=0; j<s2In.getStrvec().size(); j++) { |
| ArrayList<ArrayList<String>> ss2Vec = s2In.getStrvec().get(j); |
| ArrayList<ArrayList<String>> ss1Vec = s1Out.getStrvec().get(j); |
| for (k=0; k<ss2Vec.size(); k++) { |
| ArrayList<String> s2Vec = ss2Vec.get(k); |
| ArrayList<String> s1Vec = ss1Vec.get(k); |
| for (l=0; l<s2Vec.size(); l++) { |
| assertTrue("Error comparing strVec fields", (0 == s2Vec.get(l).compareTo(s1Vec.get(l)))); |
| } |
| } |
| } |
| assertTrue("Incorrectly read map1 field", null == s2In.getMap1()); |
| for (j=0; j<s2In.getMvec2().size(); j++) { |
| assertTrue("Error comparing mvec2 fields", (s2In.getMvec2().get(j).equals(s1Out.getMvec2().get(j)))); |
| } |
| } |
| |
| } catch (IOException ex) { |
| ex.printStackTrace(); |
| } |
| } |
| |
| } |