tests for arithmetic operations

Author: olympichek

crates/move-bytecode-verifier/src/type_safety_tests/mod.rs

@@ -4,6 +4,7 @@ use move_binary_format::file_format::{
     FunctionDefinitionIndex, empty_module
 };
 
+use move_core_types::u256::U256;
 use move_core_types::vm_status::StatusCode;
 use move_binary_format::CompiledModule;
 use move_bytecode_verifier_meter::dummy::DummyMeter;
@@ -181,3 +182,115 @@ fn test_cast_no_arg() {
         let _result = type_safety::verify(&module, &fun_context, &mut DummyMeter);
     }
 }
+
+
+
+#[test]
+fn test_arithmetic_correct_types() {
+    for instr in vec![
+        Bytecode::Add,
+        Bytecode::Sub,
+        Bytecode::Mul,
+        Bytecode::Mod,
+        Bytecode::Div,
+        Bytecode::BitOr,
+        Bytecode::BitAnd,
+        Bytecode::Xor,
+    ] {
+        for push_ty_instr in vec![
+            Bytecode::LdU8(42),
+            Bytecode::LdU16(257),
+            Bytecode::LdU32(89),
+            Bytecode::LdU64(94),
+            Bytecode::LdU128(Box::new(9999)),
+            Bytecode::LdU256(Box::new(U256::from(745_u32))),
+        ] {
+            let code = vec![push_ty_instr.clone(), push_ty_instr.clone(), instr.clone()];
+            let module = make_module(code);
+            let fun_context = get_fun_context(&module);
+            let result = type_safety::verify(&module, &fun_context, &mut DummyMeter);
+            assert!(result.is_ok());
+        }
+    }
+}
+
+#[test]
+fn test_arithmetic_mismatched_types() {
+    for instr in vec![
+        Bytecode::Add,
+        Bytecode::Sub,
+        Bytecode::Mul,
+        Bytecode::Mod,
+        Bytecode::Div,
+        Bytecode::BitOr,
+        Bytecode::BitAnd,
+        Bytecode::Xor,
+    ] {
+        let code = vec![Bytecode::LdU8(42), Bytecode::LdU64(94), instr];
+        let module = make_module(code);
+        let fun_context = get_fun_context(&module);
+        let result = type_safety::verify(&module, &fun_context, &mut DummyMeter);
+        assert_eq!(
+            result.unwrap_err().major_status(),
+            StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR
+        );
+    }
+}
+
+#[test]
+fn test_arithmetic_wrong_type() {
+    for instr in vec![
+        Bytecode::Add,
+        Bytecode::Sub,
+        Bytecode::Mul,
+        Bytecode::Mod,
+        Bytecode::Div,
+        Bytecode::BitOr,
+        Bytecode::BitAnd,
+        Bytecode::Xor,
+    ] {
+        let code = vec![Bytecode::LdTrue, Bytecode::LdU64(94), instr.clone()];
+        let module = make_module(code);
+        let fun_context = get_fun_context(&module);
+        let result = type_safety::verify(&module, &fun_context, &mut DummyMeter);
+        assert_eq!(
+            result.unwrap_err().major_status(),
+            StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR
+        );
+
+        let code = vec![Bytecode::LdU32(94), Bytecode::LdFalse, instr.clone()];
+        let module = make_module(code);
+        let fun_context = get_fun_context(&module);
+        let result = type_safety::verify(&module, &fun_context, &mut DummyMeter);
+        assert_eq!(
+            result.unwrap_err().major_status(),
+            StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR
+        );
+    }
+}
+
+
+#[test]
+#[should_panic]
+fn test_arithmetic_too_few_args() {
+    for instr in vec![
+        Bytecode::Add,
+        Bytecode::Sub,
+        Bytecode::Mul,
+        Bytecode::Mod,
+        Bytecode::Div,
+        Bytecode::BitOr,
+        Bytecode::BitAnd,
+        Bytecode::Xor,
+    ] {
+        let code = vec![Bytecode::LdU16(42), instr.clone()];
+        let module = make_module(code);
+        let fun_context = get_fun_context(&module);
+        let _result = type_safety::verify(&module, &fun_context, &mut DummyMeter);
+
+        let code = vec![instr.clone()];
+        let module = make_module(code);
+        let fun_context = get_fun_context(&module);
+        let _result = type_safety::verify(&module, &fun_context, &mut DummyMeter);
+    }
+}