chore: add more tests for Move 2 features (#111)

Author: ctoyan

move-mutator/tests/basic_tests.rs

@@ -37,7 +37,6 @@ const PACKAGE_PATHS: &[&str] = &[
     "tests/move-assets/skip_mutation_examples",
     "tests/move-assets/check_swap_operator",
     "tests/move-assets/simple_move_2_features",
-    "tests/move-assets/function_values",
 ];
 
 // Check if the mutator works correctly on the basic packages.

move-mutator/tests/move-assets/function_values/Move.toml

@@ -0,0 +1,32 @@
+module TestAccount::Enums {
+	use std::string::{String, utf8};
+
+    enum Shape has drop {
+        Rectangle { width: u64, height: u64 }
+    }
+
+    fun rectangle_area(shape: Shape): u64 {
+		assert!(shape is Shape::Rectangle);
+		shape.width*shape.height
+    }
+
+	enum Colour { Red, Green, Blue }
+
+	fun colour_enum_to_string(colour: Colour): String {
+		match (colour) {
+			Red => utf8(b"red"),
+			Green => utf8(b"green"),
+			Blue => utf8(b"blue"),
+		}
+	}
+
+    #[test]
+    fun area_of_rectangle() {
+        assert!(rectangle_area(Shape::Rectangle{width: 5, height: 5}) == 25);
+    }
+
+    #[test]
+    fun print_color_from_enum() {
+        assert!(colour_enum_to_string(Colour::Red) == utf8(b"red"));
+    }
+}

move-mutator/tests/move-assets/function_values/report.txt.mutation-exp

@@ -0,0 +1,71 @@
+module TestAccount::FriendVisibility {
+    friend TestAccount::FriendHelper;
+
+    public(friend) fun multiply(a: u64, b: u64): u64 {
+        a * b
+    }
+
+    friend fun divide(a: u64, b: u64): u64 {
+        a / b
+    }
+
+    public(friend) fun is_greater(a: u64, b: u64): bool {
+        a > b
+    }
+
+    #[test]
+    fun test_multiply() {
+        assert!(multiply(5, 10) == 50);
+        assert!(multiply(0, 100) == 0);
+        assert!(multiply(7, 7) == 49);
+    }
+
+    #[test]
+    fun test_divide() {
+        assert!(divide(10, 2) == 5);
+        assert!(divide(100, 10) == 10);
+        assert!(divide(7, 2) == 3);
+    }
+
+    #[test]
+    fun test_is_greater() {
+        assert!(is_greater(10, 5) == true);
+        assert!(is_greater(5, 10) == false);
+        assert!(is_greater(5, 5) == false);
+    }
+}
+
+module TestAccount::FriendHelper {
+    use TestAccount::FriendVisibility;
+
+    fun compute_area(width: u64, height: u64): u64 {
+        FriendVisibility::multiply(width, height)
+    }
+
+    fun average(total: u64, count: u64): u64 {
+        FriendVisibility::divide(total, count)
+    }
+
+    fun max(a: u64, b: u64): u64 {
+        if (FriendVisibility::is_greater(a, b)) { a } else { b }
+    }
+
+    #[test]
+    fun test_compute_area() {
+        assert!(compute_area(5, 10) == 50);
+        assert!(compute_area(10, 10) == 100);
+    }
+
+    #[test]
+    fun test_average() {
+        assert!(average(100, 10) == 10);
+        assert!(average(50, 2) == 25);
+    }
+
+    #[test]
+    fun test_max() {
+        assert!(max(10, 5) == 10);
+        assert!(max(5, 10) == 10);
+        assert!(max(7, 7) == 7);
+    }
+}

move-mutator/tests/move-assets/simple_move_2_features/report.txt.mutation-exp

@@ -0,0 +1,55 @@
+module TestAccount::IndexNotation {
+    fun get_element(v: &vector<u64>, i: u64): u64 {
+        v[i]
+    }
+
+    fun sum_first_two(v: &vector<u64>): u64 {
+        v[0] + v[1]
+    }
+
+    fun increment_element(v: &mut vector<u64>, i: u64) {
+        *(&mut v[i]) = v[i] + 1;
+    }
+
+    fun is_element_greater(v: &vector<u64>, i: u64, threshold: u64): bool {
+        v[i] > threshold
+    }
+
+    #[test]
+    fun test_get_element() {
+        let v = vector[10, 20, 30, 40];
+        assert!(get_element(&v, 0) == 10);
+        assert!(get_element(&v, 1) == 20);
+        assert!(get_element(&v, 2) == 30);
+        assert!(get_element(&v, 3) == 40);
+    }
+
+    #[test]
+    fun test_sum_first_two() {
+        let v = vector[5, 10, 15];
+        assert!(sum_first_two(&v) == 15);
+
+        let v2 = vector[100, 200, 300];
+        assert!(sum_first_two(&v2) == 300);
+    }
+
+    #[test]
+    fun test_increment_element() {
+        let v = vector[10, 20, 30];
+        increment_element(&mut v, 0);
+        assert!(v[0] == 11);
+        assert!(v[1] == 20);
+
+        increment_element(&mut v, 1);
+        assert!(v[1] == 21);
+    }
+
+    #[test]
+    fun test_is_element_greater() {
+        let v = vector[10, 20, 30];
+        assert!(is_element_greater(&v, 0, 5) == true);
+        assert!(is_element_greater(&v, 0, 10) == false);
+        assert!(is_element_greater(&v, 2, 25) == true);
+        assert!(is_element_greater(&v, 2, 30) == false);
+    }
+}

move-mutator/tests/move-assets/simple_move_2_features/report.txt.spec-exp

@@ -0,0 +1,71 @@
+module TestAccount::NewCastSyntax {
+    fun u64_to_u128(x: u64): u128 {
+        x as u128
+    }
+
+    fun add_and_cast(a: u64, b: u64): u128 {
+        (a + b) as u128
+    }
+
+    fun multiply_and_widen(a: u64, b: u64): u128 {
+        (a as u128) * (b as u128)
+    }
+
+    fun compare_after_cast(x: u64, threshold: u128): bool {
+        (x as u128) > threshold
+    }
+
+    fun cast_down_if_small(x: u128): u64 {
+        if (x <= 18446744073709551615) {
+            x as u64
+        } else {
+            0
+        }
+    }
+
+    fun divide_and_cast(numerator: u64, denominator: u64): u128 {
+        (numerator / denominator) as u128
+    }
+
+    #[test]
+    fun test_u64_to_u128() {
+        assert!(u64_to_u128(0) == 0);
+        assert!(u64_to_u128(100) == 100);
+        assert!(u64_to_u128(999999) == 999999);
+    }
+
+    #[test]
+    fun test_add_and_cast() {
+        assert!(add_and_cast(10, 20) == 30);
+        assert!(add_and_cast(0, 0) == 0);
+        assert!(add_and_cast(1000, 2000) == 3000);
+    }
+
+    #[test]
+    fun test_multiply_and_widen() {
+        assert!(multiply_and_widen(10, 20) == 200);
+        assert!(multiply_and_widen(100, 100) == 10000);
+        assert!(multiply_and_widen(0, 999) == 0);
+    }
+
+    #[test]
+    fun test_compare_after_cast() {
+        assert!(compare_after_cast(100, 50) == true);
+        assert!(compare_after_cast(50, 100) == false);
+        assert!(compare_after_cast(100, 100) == false);
+    }
+
+    #[test]
+    fun test_cast_down_if_small() {
+        assert!(cast_down_if_small(100) == 100);
+        assert!(cast_down_if_small(0) == 0);
+        assert!(cast_down_if_small(1000) == 1000);
+    }
+
+    #[test]
+    fun test_divide_and_cast() {
+        assert!(divide_and_cast(100, 10) == 10);
+        assert!(divide_and_cast(50, 2) == 25);
+        assert!(divide_and_cast(7, 2) == 3);
+    }
+}