Add my test library

1 files changed, 378 insertions, 0 deletions

diff --git a/output/negative/AssignWrongType-error1.java b/output/negative/AssignWrongType-error1.java
new file mode 100644
index 0000000..73c44b8
--- /dev/null
+++ b/output/negative/AssignWrongType-error1.java
@@ -0,0 +1,378 @@
+// The classes are basically the same as the BinaryTree
+// file except the visitor classes and the accept method
+// in the Tree class
+
+class TreeVisitor{
+    public static void main(String[] a){
+        System.out.println(new TV().Start());
+    }
+}
+
+class TV {
+
+    public int Start(){
+        Tree root ;
+        boolean ntb ;
+        int nti ;
+        MyVisitor v ;
+
+        root = new Tree();
+        ntb = root.Init(16);
+        ntb = root.Print();
+        System.out.println(100000000);
+        ntb = root.Insert(8) ;
+        ntb = root.Insert(24) ;
+        ntb = root.Insert(4) ;
+        ntb = root.Insert(12) ;
+        ntb = root.Insert(20) ;
+        ntb = root.Insert(28) ;
+        ntb = root.Insert(14) ;
+        ntb = root.Print();
+        System.out.println(100000000);
+        v = new MyVisitor();
+        System.out.println(50000000);
+        nti = root.accept(v);
+        System.out.println(100000000);
+        System.out.println(root.Search(24));
+        System.out.println(root.Search(12));
+        System.out.println(root.Search(16));
+        System.out.println(root.Search(50));
+        System.out.println(root.Search(12));
+        ntb = root.Delete(12);
+        ntb = root.Print();
+        System.out.println(root.Search(12));
+
+        return 0 ;
+    }
+
+}
+
+
+class Tree{
+    Tree left ;
+    Tree right;
+    int key ;
+    boolean has_left ;
+    boolean has_right ;
+    Tree my_null ;
+    int x ;
+
+
+
+    //Tree new_node ;
+    //Tree current_node ;
+    //Tree parent_node ;
+
+    // boolean ntb ;
+    //boolean cont ;
+    //boolean found ;
+    //int ifound ;
+    //  boolean is_root ;
+    //  int     nti ;
+    //  int key_aux ;
+    // int auxkey1 ;
+    // int auxkey2 ;
+
+    public boolean Init(int v_key){
+        key = v_key ;
+        has_left = false ;
+        has_right = false ;
+        return true ;
+    }
+
+    public boolean SetRight(Tree rn){
+        right = rn ;
+        return true ;
+    }
+
+    public boolean SetLeft(Tree ln){
+        left = ln ;
+        return true ;
+    }
+
+    public Tree GetRight(){
+        return right ;
+    }
+
+    public Tree GetLeft(){
+        return left;
+    }
+
+    public int GetKey(){
+        return key ;
+    }
+
+    public boolean SetKey(int v_key){
+        key = v_key ;
+        return true ;
+    }
+
+    public boolean GetHas_Right(){
+        return has_right ;
+    }
+
+    public boolean GetHas_Left(){
+        return has_left ;
+    }
+
+    public boolean SetHas_Left(boolean val){
+        has_left = val ;
+        return true ;
+    }
+
+    public boolean SetHas_Right(boolean val){
+        has_right = val ;
+        return true ;
+    }
+
+    public boolean Compare(int num1 , int num2){
+        boolean ntb ;
+        int nti ;
+
+        ntb = false ;
+        nti = num2 + 1 ;
+        if (num1 < num2) ntb = false ;
+        else if (!(num1 < nti)) ntb = false ;
+        else ntb = true ;
+        return ntb ;
+    }
+
+    public boolean Insert(int v_key){
+        Tree new_node ;
+        boolean ntb ;
+        Tree current_node ;
+        boolean cont ;
+        int key_aux ;
+
+        new_node = new Tree();
+        ntb = new_node.Init(v_key) ;
+        current_node = this ;
+        cont = true ;
+        while (cont){
+            key_aux = current_node.GetKey();
+            if (v_key < key_aux){
+                if (current_node.GetHas_Left())
+                    current_node = current_node.GetLeft() ;
+                else {
+                    cont = false ;
+                    ntb = current_node.SetHas_Left(true);
+                    ntb = current_node.SetLeft(new_node);
+                }
+            }
+            else{
+                if (current_node.GetHas_Right())
+                    current_node = current_node.GetRight() ;
+                else {
+                    cont = false ;
+                    ntb = current_node.SetHas_Right(true);
+                    ntb = current_node.SetRight(new_node);
+                }
+            }
+        }
+        return true ;
+    }
+
+    public boolean Delete(int v_key){
+        Tree current_node ;
+        Tree parent_node ;
+        boolean cont ;
+        boolean found ;
+        boolean ntb ;
+        boolean is_root ;
+        int key_aux ;
+
+        current_node = this ;
+        parent_node = this ;
+        cont = true ;
+        found = false ;
+        is_root = true ;
+        while (cont){
+            key_aux = current_node.GetKey();
+            if (v_key < key_aux)
+                if (current_node.GetHas_Left()){
+                    parent_node = current_node ;
+                    current_node = current_node.GetLeft() ;
+                }
+                else cont = false ;
+            else
+                if (key_aux < v_key)
+                    if (current_node.GetHas_Right()){
+                        parent_node = current_node ;
+                        current_node = current_node.GetRight() ;
+                    }
+                    else cont = false ;
+                else {
+                    if (is_root)
+                        if (!current_node.GetHas_Right() &&
+                            !current_node.GetHas_Left() )
+                            ntb = true ;
+                        else
+                            ntb = this.Remove(parent_node,current_node);
+                    else ntb = this.Remove(parent_node,current_node);
+                    found = true ;
+                    cont = false ;
+                }
+            is_root = false ;
+        }
+        return found ;
+    }
+
+    public boolean Remove(Tree p_node, Tree c_node){
+        boolean ntb ;
+        int auxkey1 ;
+        int auxkey2 ;
+
+        if (c_node.GetHas_Left())
+            ntb = this.RemoveLeft(p_node,c_node) ;
+        else
+            if (c_node.GetHas_Right())
+                ntb = this.RemoveRight(p_node,c_node) ;
+            else {
+                auxkey1 = c_node.GetKey();
+                auxkey2 = (p_node.GetLeft()).GetKey() ;
+                if (this.Compare(auxkey1,auxkey2)) {
+                    ntb = p_node.SetLeft(my_null);
+                    ntb = p_node.SetHas_Left(false);
+                }
+                else {
+                    ntb = p_node.SetRight(my_null);
+                    ntb = p_node.SetHas_Right(false);
+                }
+            }
+        return true ;
+    }
+
+    public boolean RemoveRight(Tree p_node, Tree c_node){
+        boolean ntb ;
+        while (c_node.GetHas_Right()){
+            ntb = c_node.SetKey((c_node.GetRight()).GetKey());
+            p_node = c_node ;
+            c_node = c_node.GetRight() ;
+        }
+        ntb = p_node.SetRight(my_null);
+        ntb = p_node.SetHas_Right(false);
+        return true ;
+    }
+
+    public boolean RemoveLeft(Tree p_node, Tree c_node){
+        boolean ntb ;
+        while (c_node.GetHas_Left()){
+            ntb = c_node.SetKey((c_node.GetLeft()).GetKey());
+            p_node = c_node ;
+            c_node = c_node.GetLeft() ;
+        }
+        ntb = p_node.SetLeft(my_null);
+        ntb = p_node.SetHas_Left(false);
+        return true ;
+    }
+
+
+    public int Search(int v_key){
+        Tree current_node ;
+        int ifound ;
+        boolean cont ;
+        int key_aux ;
+
+        x = false ; // TE
+        current_node = this ;
+        cont = true ;
+        ifound = 0 ;
+        while (cont){
+            key_aux = current_node.GetKey();
+            if (v_key < key_aux)
+                if (current_node.GetHas_Left())
+                    current_node = current_node.GetLeft() ;
+                else cont = false ;
+            else
+                if (key_aux < v_key)
+                    if (current_node.GetHas_Right())
+                        current_node = current_node.GetRight() ;
+                    else cont = false ;
+                else {
+                    ifound = 1 ;
+                    cont = false ;
+                }
+        }
+        return ifound ;
+    }
+
+    public boolean Print(){
+        boolean ntb ;
+        Tree current_node ;
+
+        current_node = this ;
+        ntb = this.RecPrint(current_node);
+        return true ;
+    }
+
+    public boolean RecPrint(Tree node){
+        boolean ntb ;
+
+        if (node.GetHas_Left()){
+            ntb = this.RecPrint(node.GetLeft());
+        } else ntb = true ;
+        System.out.println(node.GetKey());
+        if (node.GetHas_Right()){
+            ntb = this.RecPrint(node.GetRight());
+        } else ntb = true ;
+        return true ;
+    }
+
+    public int accept(Visitor v){
+        int nti ;
+
+        System.out.println(333);
+        nti = v.visit(this) ;
+        return 0 ;
+    }
+
+}
+
+
+
+class Visitor {
+    Tree l ;
+    Tree r ;
+
+    public int visit(Tree n){
+        int nti ;
+
+        if (n.GetHas_Right()){
+            r = n.GetRight() ;
+            nti = r.accept(this) ; }
+        else nti = 0 ;
+
+        if (n.GetHas_Left()) {
+            l = n.GetLeft();
+            nti = l.accept(this) ; }
+        else nti = 0 ;
+
+        return 0;
+    }
+
+}
+
+
+class MyVisitor extends Visitor {
+
+    Tree r;
+
+    public int visit(Tree n){
+        int nti ;
+
+        if (n.GetHas_Right()){
+            r = n.GetRight() ;
+            nti = r.accept(this) ; }
+        else nti = 0 ;
+
+        System.out.println(n.GetKey());
+
+        if (n.GetHas_Left()) {
+            l = n.GetLeft();
+            nti =l.accept(this) ; }
+        else nti = 0 ;
+
+        return 0;
+    }
+
+}