TestRecordVersioning.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:9k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.record;
  19. import java.io.IOException;
  20. import junit.framework.*;
  21. import java.io.File;
  22. import java.io.FileInputStream;
  23. import java.io.FileOutputStream;
  24. import java.util.ArrayList;
  25. import java.util.TreeMap;
  26. import org.apache.hadoop.record.meta.RecordTypeInfo;
  27. /**
  28.  */
  29. public class TestRecordVersioning extends TestCase {
  30.     
  31.   public TestRecordVersioning(String testName) {
  32.     super(testName);
  33.   }
  34.   protected void setUp() throws Exception {
  35.   }
  36.   protected void tearDown() throws Exception {
  37.   }
  38.     
  39.   /* 
  40.    * basic versioning
  41.    * write out a record and its type info, read it back using its typeinfo
  42.    */
  43.   public void testBasic() {
  44.     File tmpfile, tmpRTIfile;
  45.     try {
  46.       tmpfile = File.createTempFile("hadooprec", ".dat");
  47.       tmpRTIfile = File.createTempFile("hadooprti", ".dat");
  48.       FileOutputStream ostream = new FileOutputStream(tmpfile);
  49.       BinaryRecordOutput out = new BinaryRecordOutput(ostream);
  50.       FileOutputStream oRTIstream = new FileOutputStream(tmpRTIfile);
  51.       BinaryRecordOutput outRTI = new BinaryRecordOutput(oRTIstream);
  52.       RecRecord1 r1 = new RecRecord1();
  53.       r1.setBoolVal(true);
  54.       r1.setByteVal((byte)0x66);
  55.       r1.setFloatVal(3.145F);
  56.       r1.setDoubleVal(1.5234);
  57.       r1.setIntVal(-4567);
  58.       r1.setLongVal(-2367L);
  59.       r1.setStringVal("random text");
  60.       r1.setBufferVal(new Buffer());
  61.       r1.setVectorVal(new ArrayList<String>());
  62.       r1.setMapVal(new TreeMap<String,String>());
  63.       RecRecord0 r0 = new RecRecord0();
  64.       r0.setStringVal("other random text");
  65.       r1.setRecordVal(r0);
  66.       r1.serialize(out, "");
  67.       ostream.close();
  68.       // write out the type info
  69.       RecRecord1.getTypeInfo().serialize(outRTI);
  70.       oRTIstream.close();
  71.       
  72.       // read
  73.       FileInputStream istream = new FileInputStream(tmpfile);
  74.       BinaryRecordInput in = new BinaryRecordInput(istream);
  75.       FileInputStream iRTIstream = new FileInputStream(tmpRTIfile);
  76.       BinaryRecordInput inRTI = new BinaryRecordInput(iRTIstream);
  77.       RecordTypeInfo rti = new RecordTypeInfo();
  78.       rti.deserialize(inRTI);
  79.       iRTIstream.close();
  80.       RecRecord1.setTypeFilter(rti);
  81.       RecRecord1 r2 = new RecRecord1();
  82.       r2.deserialize(in, "");
  83.       istream.close();
  84.       tmpfile.delete();
  85.       tmpRTIfile.delete();
  86.       assertTrue("Serialized and deserialized versioned records do not match.", r1.equals(r2));
  87.     } catch (IOException ex) {
  88.       ex.printStackTrace();
  89.     } 
  90.   }
  91.     
  92.   /* 
  93.    * versioning
  94.    * write out a record and its type info, read back a similar record using the written record's typeinfo
  95.    */
  96.   public void testVersioning() {
  97.     File tmpfile, tmpRTIfile;
  98.     try {
  99.       tmpfile = File.createTempFile("hadooprec", ".dat");
  100.       tmpRTIfile = File.createTempFile("hadooprti", ".dat");
  101.       FileOutputStream ostream = new FileOutputStream(tmpfile);
  102.       BinaryRecordOutput out = new BinaryRecordOutput(ostream);
  103.       FileOutputStream oRTIstream = new FileOutputStream(tmpRTIfile);
  104.       BinaryRecordOutput outRTI = new BinaryRecordOutput(oRTIstream);
  105.       // we create an array of records to write
  106.       ArrayList<RecRecordOld> recsWrite = new ArrayList<RecRecordOld>();
  107.       int i, j, k, l;
  108.       for (i=0; i<5; i++) {
  109.         RecRecordOld s1Rec = new RecRecordOld();
  110.         s1Rec.setName("This is record s1: " + i);
  111.         ArrayList<Long> iA = new ArrayList<Long>();
  112.         for (j=0; j<3; j++) {
  113.           iA.add(new Long(i+j));
  114.         }
  115.         s1Rec.setIvec(iA);
  116.         ArrayList<ArrayList<RecRecord0>> ssVec = new ArrayList<ArrayList<RecRecord0>>();
  117.         for (j=0; j<2; j++) {
  118.           ArrayList<RecRecord0> sVec = new ArrayList<RecRecord0>();
  119.           for (k=0; k<3; k++) {
  120.             RecRecord0 sRec = new RecRecord0("This is record s: ("+j+": "+k+")");
  121.             sVec.add(sRec);
  122.           }
  123.           ssVec.add(sVec);
  124.         }
  125.         s1Rec.setSvec(ssVec);
  126.         s1Rec.setInner(new RecRecord0("This is record s: " + i));
  127.         ArrayList<ArrayList<ArrayList<String>>> aaaVec = new ArrayList<ArrayList<ArrayList<String>>>();
  128.         for (l=0; l<2; l++) {
  129.           ArrayList<ArrayList<String>> aaVec = new ArrayList<ArrayList<String>>();
  130.           for (j=0; j<2; j++) {
  131.             ArrayList<String> aVec = new ArrayList<String>();
  132.             for (k=0; k<3; k++) {
  133.               aVec.add(new String("THis is a nested string: (" + l + ": " + j + ": " + k + ")"));
  134.             }
  135.             aaVec.add(aVec);
  136.           }
  137.           aaaVec.add(aaVec);
  138.         }
  139.         s1Rec.setStrvec(aaaVec);
  140.         s1Rec.setI1(100+i);
  141.         java.util.TreeMap<Byte,String> map1 = new java.util.TreeMap<Byte,String>();
  142.         map1.put(new Byte("23"), "23");
  143.         map1.put(new Byte("11"), "11");
  144.         s1Rec.setMap1(map1);
  145.         java.util.TreeMap<Integer,Long> m1 = new java.util.TreeMap<Integer,Long>();
  146.         java.util.TreeMap<Integer,Long> m2 = new java.util.TreeMap<Integer,Long>();
  147.         m1.put(new Integer(5), 5L);
  148.         m1.put(new Integer(10), 10L);
  149.         m2.put(new Integer(15), 15L);
  150.         m2.put(new Integer(20), 20L);
  151.         java.util.ArrayList<java.util.TreeMap<Integer,Long>> vm1 = new java.util.ArrayList<java.util.TreeMap<Integer,Long>>();
  152.         vm1.add(m1);
  153.         vm1.add(m2);
  154.         s1Rec.setMvec1(vm1);
  155.         java.util.ArrayList<java.util.TreeMap<Integer,Long>> vm2 = new java.util.ArrayList<java.util.TreeMap<Integer,Long>>();
  156.         vm2.add(m1);
  157.         s1Rec.setMvec2(vm2);
  158.         // add to our list
  159.         recsWrite.add(s1Rec);
  160.       }
  161.       // write out to file
  162.       for (RecRecordOld rec: recsWrite) {
  163.         rec.serialize(out);
  164.       }
  165.       ostream.close();
  166.       // write out the type info
  167.       RecRecordOld.getTypeInfo().serialize(outRTI);
  168.       oRTIstream.close();
  169.       // read
  170.       FileInputStream istream = new FileInputStream(tmpfile);
  171.       BinaryRecordInput in = new BinaryRecordInput(istream);
  172.       FileInputStream iRTIstream = new FileInputStream(tmpRTIfile);
  173.       BinaryRecordInput inRTI = new BinaryRecordInput(iRTIstream);
  174.       RecordTypeInfo rti = new RecordTypeInfo();
  175.       // read type info
  176.       rti.deserialize(inRTI);
  177.       iRTIstream.close();
  178.       RecRecordNew.setTypeFilter(rti);
  179.       // read records
  180.       ArrayList<RecRecordNew> recsRead = new ArrayList<RecRecordNew>();
  181.       for (i=0; i<recsWrite.size(); i++) {
  182.         RecRecordNew s2Rec = new RecRecordNew();
  183.         s2Rec.deserialize(in);
  184.         recsRead.add(s2Rec);
  185.       }
  186.       istream.close();
  187.       tmpfile.delete();
  188.       tmpRTIfile.delete();
  189.       // compare
  190.       for (i=0; i<recsRead.size(); i++) {
  191.         RecRecordOld s1Out = recsWrite.get(i);
  192.         RecRecordNew s2In = recsRead.get(i);
  193.         assertTrue("Incorrectly read name2 field", null == s2In.getName2());
  194.         assertTrue("Error comparing inner fields", (0 == s1Out.getInner().compareTo(s2In.getInner())));
  195.         assertTrue("Incorrectly read ivec field", null == s2In.getIvec());
  196.         assertTrue("Incorrectly read svec field", null == s2In.getSvec());
  197.         for (j=0; j<s2In.getStrvec().size(); j++) {
  198.           ArrayList<ArrayList<String>> ss2Vec = s2In.getStrvec().get(j);
  199.           ArrayList<ArrayList<String>> ss1Vec = s1Out.getStrvec().get(j);
  200.           for (k=0; k<ss2Vec.size(); k++) {
  201.             ArrayList<String> s2Vec = ss2Vec.get(k);
  202.             ArrayList<String> s1Vec = ss1Vec.get(k);
  203.             for (l=0; l<s2Vec.size(); l++) {
  204.               assertTrue("Error comparing strVec fields", (0 == s2Vec.get(l).compareTo(s1Vec.get(l))));
  205.             }
  206.           }
  207.         }
  208.         assertTrue("Incorrectly read map1 field", null == s2In.getMap1());
  209.         for (j=0; j<s2In.getMvec2().size(); j++) {
  210.           assertTrue("Error comparing mvec2 fields", (s2In.getMvec2().get(j).equals(s1Out.getMvec2().get(j))));
  211.         }
  212.       }
  213.     } catch (IOException ex) {
  214.       ex.printStackTrace();
  215.     } 
  216.   }
  217. }