Adding and updating unit tests

Author: svorenova

unit/goto-programs/goto_program_generics/GenericBases.java

@@ -0,0 +1,123 @@
+// Helper classes
+class Wrapper<T> {
+  public T field;
+}
+
+class IntWrapper {
+  public int i;
+}
+
+class TwoWrapper<K, V> {
+  public K first;
+  public V second;
+}
+
+interface InterfaceWrapper<T> {
+  public T method(T t);
+}
+
+// A class extending a generic class instantiated with a standard library class
+class SuperclassInst extends Wrapper<Integer> {
+  public void foo() {
+    this.field = 5;
+  }
+}
+
+// A class extending a generic class instantiated with a user-defined class
+class SuperclassInst2 extends Wrapper<IntWrapper> {
+  public void foo() {
+    this.field.i = 5;
+  }
+}
+
+// A class extending an instantiated nested generic class
+class SuperclassInst3 extends Wrapper<Wrapper<IntWrapper>> {
+  public void foo() {
+    this.field.field.i = 5;
+  }
+}
+
+// A generic class extending a generic class (must be with the same parameter)
+class SuperclassUninst<U> extends Wrapper<U> {
+  public void foo(U value) {
+    this.field = value;
+  }
+}
+class SuperclassUninstTest
+{
+  SuperclassUninst<Integer> f;
+  public void foo() {
+    f.foo(new Integer(1));
+  }
+}
+
+
+// A generic class extending a generic class with both instantiated and
+// uninstantiated parameters
+class SuperclassMixed<U> extends TwoWrapper<U,IntWrapper> {
+  public void foo(U value) {
+    this.first = value;
+    this.second.i = 5;
+  }
+}
+class SuperclassMixedTest
+{
+  SuperclassMixed<Boolean> f;
+  public void foo() {
+    f.foo(true);
+  }
+}
+
+// Inner classes (generic or not) extending generic classes
+class SuperclassInnerInst {
+  class Inner extends Wrapper<Integer> {
+    public void foo() {
+      this.field = 5;
+    }
+  }
+  public Inner inner;
+
+  class InnerGen<T> extends Wrapper<T> {
+    public void foo(T value) {
+      this.field = value;
+    }
+  }
+  public InnerGen<Boolean> inner_gen;
+
+  public void foo() {
+    inner.foo();
+    inner_gen.foo(true);
+  }
+}
+
+// Implicitly generic inner classes (generic or not) extending generic classes
+class SuperclassInnerUninst<U> {
+  class Inner extends Wrapper<U> {
+    public void foo(U value) {
+      this.field = value;
+    }
+  }
+  public Inner inner;
+
+  class InnerGen<T> extends TwoWrapper<U,T> {
+    public void foo(U uvalue, T tvalue) {
+      this.first = uvalue;
+      this.second = tvalue;
+    }
+  }
+  public InnerGen<Boolean> inner_gen;
+
+  class InnerThree extends Inner {
+  }
+  public InnerThree inner_three;
+}
+class SuperclassInnerUninstTest
+{
+  SuperclassInnerUninst<IntWrapper> f;
+  public void foo() {
+    IntWrapper x = new IntWrapper();
+    f.inner.foo(x);
+    f.inner_gen.foo(x,true);
+    f.inner_three.foo(x);
+  }
+}

unit/goto-programs/goto_program_generics/GenericFields$GenericInnerOuter$Outer$InnerClass.class

@@ -0,0 +1,98 @@
+class SimpleWrapper<T> {
+  public T field;
+  public T[] array_field;
+
+  public int int_field;
+}
+
+class IWrapper {
+  public int i;
+}
+
+class PairWrapper<K, V> {
+  public K key;
+  public V value;
+}
+
+public class GenericFields
+{
+  IWrapper field;
+  class SimpleGenericField  {
+    SimpleWrapper<IWrapper> field_input;
+    public void foo() {
+        field_input.field.i = 5;
+        field_input.array_field = new IWrapper[2];
+    }
+  }
+
+  class MultipleGenericFields {
+    SimpleWrapper<IWrapper> field_input1;
+    SimpleWrapper<IWrapper> field_input2;
+    public void foo() {
+        field_input1.field.i = 10;
+        field_input2.field.i = 20;
+    }
+  }
+
+  class NestedGenericFields {
+    SimpleWrapper<SimpleWrapper<IWrapper>> field_input1;
+    public void foo() {
+        field_input1.field.field.i = 30;
+    }
+  }
+
+  class PairGenericField {
+    PairWrapper<IWrapper, IWrapper> field_input;
+    public void foo() {
+        field_input.key.i = 40;
+        field_input.value.i = 50;
+    }
+  }
+
+  class GenericMethodParameter {
+    public void foo(SimpleWrapper<IWrapper> v) {
+        v.field.i = 20;
+    }
+  }
+
+  class GenericMethodUninstantiatedParameter {
+    public <T> void foo_unspec(SimpleWrapper<T> v) {
+        v.int_field=10;
+    }
+  }
+
+  class GenericInnerOuter {
+    class Outer<T> {
+        public class InnerClass
+        {
+            T t;
+        }
+
+        public Outer()
+        {
+            field = new InnerClass();
+        }
+
+        public InnerClass field;
+    }
+
+    public void foo(Outer<Integer> v) {
+        Outer t = new Outer<Integer>();
+        t.field.t = v.field.t;
+    }
+  }
+
+  class GenericRewriteParameter {
+    class A<T> {
+      T value;
+      A<Boolean> field;
+    }
+
+    public void foo(A<Integer> v) {
+      if(v.field.value)
+      {
+        v.value = 1;
+      }
+    }
+  }
+}