src/tests/gov/nasa/jpf/util/ObjVectorTest.java

   1 /*
   2  * Copyright (C) 2014, United States Government, as represented by the
   3  * Administrator of the National Aeronautics and Space Administration.
   4  * All rights reserved.
   5  *
   6  * The Java Pathfinder core (jpf-core) platform is licensed under the
   7  * Apache License, Version 2.0 (the "License"); you may not use this file except
   8  * in compliance 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 gov.nasa.jpf.util;
  19
  20 import org.junit.Test;
  21
  22 import gov.nasa.jpf.util.test.TestJPF;
  23
  24 /**
  25  * regression test for ObjVector
  26  */
  27 public class ObjVectorTest extends TestJPF {
  28
  29   void assertEquals( ObjVector<Integer> v1, ObjVector<Integer> v2) {
  30     assertTrue( v1.size() == v2.size());
  31
  32     int n = v1.size();
  33     for (int i=0; i<n; i++) {
  34       Object a = v1.get(i);
  35       Object b = v2.get(i);
  36       if (a == null) {
  37         assertTrue( b == null);
  38       } else {
  39         assertTrue( a.equals(b));
  40       }
  41     }
  42   }
  43
  44   @Test
  45   public void testSnapshot () {
  46     ObjVector<Integer> v = new ObjVector<Integer>(100);
  47
  48     // all empty snapshot
  49     ObjVector.Snapshot<Integer> snap = v.getSnapshot();
  50     Integer val = Integer.valueOf(42);
  51     v.set(0,  val);
  52     assertTrue(v.size() == 1 && v.get(0) == val);
  53     v.restore(snap);
  54     assertTrue(v.size() == 0 && v.get(0) == null);
  55
  56     //--- all full snapshot
  57     for (int i=0; i<100; i++) {
  58       v.set(i, i);
  59     }
  60     ObjVector<Integer> v0 = v.clone();
  61     ObjVector.Snapshot<Integer> snap0 = v.getSnapshot();
  62     v.clear();
  63     v.restore(snap0);
  64     assertEquals( v0, v);
  65
  66     //--- punch holes into it
  67     v.setRange(11,  20, null);
  68     v.set( 25,null);
  69     v.set( 26, null);
  70     v.set( 42, null);
  71     v.setRange(70, 85, null);
  72     ObjVector.Snapshot<Integer> snap1 = v.getSnapshot();
  73     ObjVector<Integer> v1 = v.clone();
  74     v.clear();
  75     v.restore(snap1);
  76     //v.printOn( System.out);
  77     assertEquals( v1, v);
  78
  79     //--- chop off the ends
  80     v.restore(snap0);
  81     v.setRange(81, 99, null);
  82     v.setRange(0, 19, null);
  83     ObjVector.Snapshot<Integer> snap2 = v.getSnapshot();
  84     ObjVector<Integer> v2 = v.clone();
  85     v.clear();
  86     v.restore(snap2);
  87     assertEquals( v2, v);
  88   }
  89
  90   //--- mutating snapshot
  91
  92   static class X {
  93     int val;
  94     X (Integer o) { val = o.intValue(); }
  95   }
  96
  97   static class IXTransformer implements Transformer<Integer,X> {
  98     @Override
  99         public X transform( Integer obj) {
 100       return new X(obj);
 101     }
 102   }
 103
 104   static class XITransformer implements Transformer<X,Integer>{
 105     @Override
 106         public Integer transform( X obj) {
 107       return Integer.valueOf(obj.val);
 108     }
 109   }
 110
 111   @Test
 112   public void testMutatingSnapshot() {
 113     ObjVector<Integer> v = new ObjVector<Integer>(100);
 114
 115     for (int i=0; i<100; i+=2) {
 116       v.set(i, Integer.valueOf(i));
 117     }
 118     print(v);
 119
 120     System.out.println("now storing snapshot for ObjVector of size " + v.size());
 121     ObjVector.MutatingSnapshot<Integer,X> snap = v.getSnapshot(new IXTransformer());
 122
 123     System.out.println("now modifying ObjVector");
 124     v.clear();
 125     v.setRange(0, 30, Integer.valueOf(42));
 126     print(v);
 127
 128     System.out.println("now restoring ObjVector");
 129     v.restore(snap, new XITransformer());
 130
 131     int n = print(v);
 132     assert n == 50 : "got wrong number of non-null elements: " + n;
 133   }
 134
 135   // utilities
 136
 137   int print(ObjVector<Integer> v) {
 138     int n = 0;
 139     for (int i=0; i<=v.size(); i++) {
 140       Integer e = v.get(i);
 141       if (e != null) {
 142         if (n++ > 0) {
 143           System.out.print(',');
 144         }
 145         System.out.print(e);
 146       }
 147     }
 148     System.out.println();
 149
 150     return n;
 151   }
 152 }