Add some test for static and virtual calls

Author: Lipen

usvm-ts/src/test/kotlin/org/usvm/samples/Call.kt

@@ -164,6 +164,65 @@ class Call : TsMethodTestRunner() {
             { r -> r.number == 30.0 }
         )
     }
+
+    @Disabled("Static calls are broken in IR")
+    @Test
+    fun `test static`() {
+        val method = getMethod(className, "callStatic")
+        discoverProperties<TsValue.TsNumber>(
+            method = method,
+            { r -> r.number == 50.0 }
+        )
+    }
+
+    @Disabled("Inheritance is broken")
+    @Test
+    fun `test virtual call`() {
+        val method = getMethod(className, "callVirtual")
+        discoverProperties<TsValue.TsClass, TsValue.TsNumber>(
+            method = method,
+            { obj, r ->
+                when (obj.name) {
+                    "Parent" -> r.number == 100.0
+                    "Child" -> r.number == 200.0
+                    else -> false
+                }
+            },
+        )
+    }
+
+    @Test
+    fun `test virtual parent`() {
+        val method = getMethod(className, "callVirtualParent")
+        discoverProperties<TsValue.TsNumber>(
+            method = method,
+            { r -> r.number == 100.0 },
+        )
+    }
+
+    @Disabled("Calls to super are broken in IR")
+    @Test
+    fun `test virtual child`() {
+        val method = getMethod(className, "callVirtualChild")
+        discoverProperties<TsValue.TsNumber>(
+            method = method,
+            { r -> r.number == 200.0 },
+        )
+    }
+
+    @Disabled("Too complex")
+    @Test
+    fun `test virtual dispatch`() {
+        val method = getMethod(className, "virtualDispatch")
+        discoverProperties<TsValue.TsClass, TsValue.TsNumber>(
+            method = method,
+            { obj, r -> obj.name == "Parent" && r.number == 100.0 },
+            { obj, r -> obj.name == "Child" && r.number == 200.0 },
+            invariants = arrayOf(
+                { _, r -> r.number != -1.0 },
+            )
+        )
+    }
 }
 
 fun fib(n: Double): Double {

usvm-ts/src/test/resources/samples/Call.ts

@@ -95,6 +95,37 @@ class Call {
     callNamespace(): number {
         return new N1.C().foo();
     }
+
+    static fifty(): number {
+        return 50;
+    }
+
+    callStatic(): number {
+        return Call.fifty();
+    }
+
+    callVirtual(obj: Parent): number {
+        return obj.virtualMethod(); // 100 or 200
+    }
+
+    callVirtualParent(): number {
+        let obj: Parent = new Parent();
+        return obj.virtualMethod(); // 100
+    }
+
+    callVirtualChild(): number {
+        let obj: Child = new Child();
+        return obj.virtualMethod(); // 200
+    }
+
+    virtualDispatch(obj: Parent): number {
+        if (obj instanceof Child) {
+            return obj.virtualMethod(); // 200
+        } else if (obj instanceof Parent) {
+            return obj.virtualMethod(); // 100
+        }
+        return -1; // unreachable
+    }
 }
 
 class A {
@@ -126,13 +157,17 @@ namespace N2 {
 }
 
 class Parent {
+    depth = 1;
+
     virtualMethod(): number {
-        return 1;
+        return 100;
     }
 }
 
 class Child extends Parent {
+    override depth = 2;
+
     override virtualMethod(): number {
-        return 2;
+        return 200;
     }
 }