First round of PR feedback

Signed-off-by: Ludvig Liljenberg <[email protected]>

Author: ludfjig

src/hyperlight_common/src/flatbuffer_wrappers/function_types.rs

@@ -738,16 +738,6 @@ impl TryFrom<ReturnValueBox<'_>> for ReturnValue {
     }
 }
 
-// impl TryFrom<&[u8]> for ReturnValue {
-//     type Error = Error;
-//     #[cfg_attr(feature = "tracing", instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace"))]
-//     fn try_from(value: &[u8]) -> Result<Self> {
-//         let function_call_result_fb = size_prefixed_root::<FbFunctionCallResult>(value)
-//             .map_err(|e| anyhow!("Failed to get ReturnValue from bytes: {:?}", e))?;
-//         function_call_result_fb.try_into()
-//     }
-// }
-
 impl TryFrom<&ReturnValue> for Vec<u8> {
     type Error = Error;
     #[cfg_attr(feature = "tracing", instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace"))]
@@ -961,3 +951,36 @@ impl TryFrom<&ReturnValue> for Vec<u8> {
         Ok(result_bytes)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use flatbuffers::FlatBufferBuilder;
+
+    use super::super::guest_error::ErrorCode;
+    use super::*;
+
+    #[test]
+    fn encode_success_result() {
+        let mut builder = FlatBufferBuilder::new();
+        let test_data = FunctionCallResult::new(Ok(ReturnValue::Int(42))).encode(&mut builder);
+
+        let function_call_result = FunctionCallResult::try_from(test_data).unwrap();
+        let result = function_call_result.into_inner().unwrap();
+        assert_eq!(result, ReturnValue::Int(42));
+    }
+
+    #[test]
+    fn encode_error_result() {
+        let mut builder = FlatBufferBuilder::new();
+        let test_error = GuestError::new(
+            ErrorCode::GuestFunctionNotFound,
+            "Function not found".to_string(),
+        );
+        let test_data = FunctionCallResult::new(Err(test_error.clone())).encode(&mut builder);
+
+        let function_call_result = FunctionCallResult::try_from(test_data).unwrap();
+        let error = function_call_result.into_inner().unwrap_err();
+        assert_eq!(error.code, test_error.code);
+        assert_eq!(error.message, test_error.message);
+    }
+}

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -561,6 +561,16 @@ mod tests {
         }
     }
 
+    #[test]
+    fn call_host_func_expect_error() {
+        let path = simple_guest_as_string().unwrap();
+        let sandbox = UninitializedSandbox::new(GuestBinary::FilePath(path), None).unwrap();
+        let mut sandbox = sandbox.evolve().unwrap();
+        sandbox
+            .call::<()>("CallHostExpectError", "SomeUnknownHostFunc".to_string())
+            .unwrap();
+    }
+
     /// Make sure input/output buffers are properly reset after guest call (with host call)
     #[test]
     fn io_buffer_reset() {

src/tests/rust_guests/simpleguest/src/main.rs

@@ -912,9 +912,45 @@ fn exec_mapped_buffer(function_call: &FunctionCall) -> Result<Vec<u8>> {
     }
 }
 
+fn call_host_expect_error(function_call: &FunctionCall) -> Result<Vec<u8>> {
+    if let ParameterValue::String(hostfuncname) =
+        function_call.parameters.clone().unwrap()[0].clone()
+    {
+        let res = call_host_function::<i32>(&hostfuncname, None, ReturnType::Int);
+
+        match res {
+            Ok(_) => Err(HyperlightGuestError::new(
+                ErrorCode::GuestError,
+                "Expected host function to fail, but it succeeded".to_string(),
+            )),
+            Err(e) => {
+                assert_eq!(e.kind, ErrorCode::HostFunctionError);
+                assert_eq!(
+                    e.message,
+                    format!("HostFunction {} was not found", hostfuncname)
+                );
+                Ok(get_flatbuffer_result(()))
+            }
+        }
+    } else {
+        Err(HyperlightGuestError::new(
+            ErrorCode::GuestFunctionParameterTypeMismatch,
+            "Invalid parameters passed to call_host_expect_error".to_string(),
+        ))
+    }
+}
+
 #[no_mangle]
 #[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn hyperlight_main() {
+    let expect_error_def = GuestFunctionDefinition::new(
+        "CallHostExpectError".to_string(),
+        Vec::from(&[ParameterType::String]),
+        ReturnType::Void,
+        call_host_expect_error as usize,
+    );
+    register_function(expect_error_def);
+
     let twenty_four_k_in_def = GuestFunctionDefinition::new(
         "24K_in_8K_out".to_string(),
         Vec::from(&[ParameterType::VecBytes]),