fluencelabs/marine
1
0
Fork 0
mirror of https://github.com/fluencelabs/marine.git synced 2025-06-26 05:01:38 +00:00
Code Issues Projects Releases Wiki Activity

Improve arrays and record passing scheme (#76)

Browse Source
This commit is contained in:
vms
2021-04-26 14:02:26 +03:00
committed by GitHub
parent c702311595
commit 96c32b64d8
79 changed files with 1109 additions and 1079 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
fluence-faas/tests/arrays_passing.rs
View File

@ -46,9 +46,9 @@ pub fn get_interfaces() {
let byte_type_arguments = vec![fluence_faas::IFunctionArg {
name: String::from("arg"),
ty: IType::Array(Box::new(IType::U8)),
ty: IType::ByteArray,
}];
let byte_type_outputs = vec![IType::Array(Box::new(IType::U8))];
let byte_type_outputs = vec![IType::ByteArray];
let byte_type_sign = fluence_faas::FaaSFunctionSignature {
name: Rc::new(String::from("byte_type")),
@ -59,11 +59,11 @@ pub fn get_interfaces() {
let inner_arrays_1_arguments = vec![fluence_faas::IFunctionArg {
name: String::from("arg"),
ty: IType::Array(Box::new(IType::Array(Box::new(IType::Array(Box::new(
IType::Array(Box::new(IType::U8)),
IType::ByteArray,
)))))),
}];
let inner_arrays_1_outputs = vec![IType::Array(Box::new(IType::Array(Box::new(
IType::Array(Box::new(IType::Array(Box::new(IType::U8)))),
IType::Array(Box::new(IType::ByteArray)),
))))];
let inner_arrays_1_sign = fluence_faas::FaaSFunctionSignature {
@ -185,24 +185,23 @@ pub fn get_interfaces() {
outputs: Rc::new(empty_type_outputs),
};
/*
let bool_type_arguments = vec![fluence_faas::IFunctionArg {
name: String::from("arg"),
ty: IType::I32,
ty: IType::Array(Box::new(IType::Boolean)),
}];
let bool_type_outputs = vec![IType::I32];
let bool_type_outputs = vec![IType::Array(Box::new(IType::Boolean))];
let bool_type_sign = fluence_faas::FaaSFunctionSignature {
name: "bool_type",
arguments: &bool_type_arguments,
outputs: &bool_type_outputs,
name: Rc::new(String::from("bool_type")),
arguments: Rc::new(bool_type_arguments),
outputs: Rc::new(bool_type_outputs),
};
*/
let functions = vec![
byte_type_sign,
inner_arrays_1_sign,
string_type_sign,
bool_type_sign,
f32_type_sign,
f64_type_sign,
u32_type_sign,
@ -249,7 +248,7 @@ pub fn i32_type() {
let mut faas = FluenceFaaS::with_raw_config(ARG_CONFIG.clone())
.unwrap_or_else(|e| panic!("can't create Fluence FaaS instance: {}", e));
let right_result = json!([0, 1, 2, 3, 4, 0, 2]);
let expected_result = json!([0, 1, 2, 3, 4, 0, 2]);
let result1 = faas
.call_with_json(
@ -259,7 +258,7 @@ pub fn i32_type() {
<_>::default(),
)
.unwrap_or_else(|e| panic!("can't invoke i32_type: {:?}", e));
assert_eq!(result1, right_result);
assert_eq!(result1, expected_result);
let result2 = faas
.call_with_json(
@ -269,9 +268,9 @@ pub fn i32_type() {
<_>::default(),
)
.unwrap_or_else(|e| panic!("can't invoke i32_type: {:?}", e));
assert_eq!(result2, right_result);
assert_eq!(result2, expected_result);
let right_result = json!([1, 0, 1, 2, 3, 4, 0, 2]);
let expected_result = json!([1, 0, 1, 2, 3, 4, 0, 2]);
let result3 = faas
.call_with_json(
"arrays_passing_pure",
@ -280,7 +279,7 @@ pub fn i32_type() {
<_>::default(),
)
.unwrap_or_else(|e| panic!("can't invoke i32_type: {:?}", e));
assert_eq!(result3, right_result);
assert_eq!(result3, expected_result);
}
#[test]
@ -294,7 +293,7 @@ pub fn i64_type() {
let result2 = faas.call_with_json("arrays_passing_pure", "i64_type", json!([]), <_>::default());
assert!(result2.is_err());
let right_result = json!([1, 0, 1, 2, 3, 4, 1, 1]);
let expected_result = json!([1, 0, 1, 2, 3, 4, 1, 1]);
let result3 = faas
.call_with_json(
@ -304,7 +303,7 @@ pub fn i64_type() {
<_>::default(),
)
.unwrap_or_else(|e| panic!("can't invoke i64_type: {:?}", e));
assert_eq!(result3, right_result);
assert_eq!(result3, expected_result);
let result4 = faas
.call_with_json(
@ -314,7 +313,7 @@ pub fn i64_type() {
<_>::default(),
)
.unwrap_or_else(|e| panic!("can't invoke i64_type: {:?}", e));
assert_eq!(result4, right_result);
assert_eq!(result4, expected_result);
}
#[test]
@ -328,7 +327,7 @@ pub fn u32_type() {
let result2 = faas.call_with_json("arrays_passing_pure", "u32_type", json!([]), <_>::default());
assert!(result2.is_err());
let right_result = json!([1, 0, 13, 37, 2]);
let expected_result = json!([1, 0, 13, 37, 2]);
let result3 = call_faas!(
faas,
@ -336,10 +335,10 @@ pub fn u32_type() {
"u32_type",
json!({ "arg": [1] })
);
assert_eq!(result3, right_result);
assert_eq!(result3, expected_result);
let result4 = call_faas!(faas, "arrays_passing_pure", "u32_type", json!([[1]]));
assert_eq!(result4, right_result);
assert_eq!(result4, expected_result);
}
#[test]
@ -353,7 +352,7 @@ pub fn u64_type() {
let result2 = faas.call_with_json("arrays_passing_pure", "u64_type", json!([]), <_>::default());
assert!(result2.is_err());
let right_result = json!([1, 0, 1, 2, 3, 4, 2]);
let expected_result = json!([1, 0, 1, 2, 3, 4, 2]);
let result3 = call_faas!(
faas,
@ -361,14 +360,14 @@ pub fn u64_type() {
"u64_type",
json!({ "arg": [1] })
);
assert_eq!(result3, right_result);
assert_eq!(result3, expected_result);
let result4 = call_faas!(faas, "arrays_passing_pure", "u64_type", json!([[1]]));
assert_eq!(result4, right_result);
assert_eq!(result4, expected_result);
}
#[test]
pub fn f64_type_() {
pub fn f64_type() {
let mut faas = FluenceFaaS::with_raw_config(ARG_CONFIG.clone())
.unwrap_or_else(|e| panic!("can't create Fluence FaaS instance: {}", e));
@ -378,7 +377,7 @@ pub fn f64_type_() {
let result2 = faas.call_with_json("arrays_passing_pure", "f32_type", json!([]), <_>::default());
assert!(result2.is_err());
let right_result = json!([1.0, 0.0, 13.37, 1.0]);
let expected_result = json!([1.0, 0.0, 13.37, 1.0]);
let result3 = call_faas!(
faas,
@ -386,36 +385,10 @@ pub fn f64_type_() {
"f64_type",
json!({ "arg": [1.0] })
);
assert_eq!(result3, right_result);
assert_eq!(result3, expected_result);
let result4 = call_faas!(faas, "arrays_passing_pure", "f64_type", json!([[1.0]]));
assert_eq!(result4, right_result);
}
#[test]
#[ignore]
pub fn f64_type() {
let mut faas = FluenceFaaS::with_raw_config(ARG_CONFIG.clone())
.unwrap_or_else(|e| panic!("can't create Fluence FaaS instance: {}", e));
let result1 = faas.call_with_json("arrays_passing_pure", "f64_type", json!({}), <_>::default());
assert!(result1.is_err());
let result2 = faas.call_with_json("arrays_passing_pure", "f64_type", json!([]), <_>::default());
assert!(result2.is_err());
let right_result = json!([3.0]);
let result3 = call_faas!(
faas,
"arrays_passing_pure",
"f64_type",
json!({ "arg": 1.0 })
);
assert_eq!(result3, right_result);
let result4 = call_faas!(faas, "arrays_passing_pure", "f64_type", json!(1.0));
assert_eq!(result4, right_result);
assert_eq!(result4, expected_result);
}
#[test]
@ -439,7 +412,7 @@ pub fn string_type() {
);
assert!(result2.is_err());
let right_result = json!(["Fluence", "fce", "from effector", "test"]);
let expected_result = json!(["Fluence", "fce", "from effector", "test"]);
let result3 = call_faas!(
faas,
@ -447,7 +420,7 @@ pub fn string_type() {
"string_type",
json!({ "arg": ["Fluence"] })
);
assert_eq!(result3, right_result);
assert_eq!(result3, expected_result);
let result4 = call_faas!(
faas,
@ -455,7 +428,7 @@ pub fn string_type() {
"string_type",
json!([["Fluence"]])
);
assert_eq!(result4, right_result);
assert_eq!(result4, expected_result);
}
#[test]
@ -479,14 +452,14 @@ pub fn byte_type() {
);
assert!(result2.is_err());
let right_result = json!([0x13, 0x37, 0, 1, 2]);
let expected_result = json!([0x13, 0x37, 0, 1, 2]);
let result3 = call_faas!(
faas,
"arrays_passing_pure",
"byte_type",
json!({ "arg": [0x13, 0x37] })
);
assert_eq!(result3, right_result);
assert_eq!(result3, expected_result);
let result4 = call_faas!(
faas,
@ -494,7 +467,7 @@ pub fn byte_type() {
"byte_type",
json!([[0x13, 0x37]])
);
assert_eq!(result4, right_result);
assert_eq!(result4, expected_result);
}
#[test]
@ -518,7 +491,7 @@ pub fn inner_arrays_1_type() {
);
assert!(result2.is_err());
let right_result = json!([
let expected_result = json!([
[[[0x13, 0x37]]],
[[[0]]],
[],
@ -533,7 +506,7 @@ pub fn inner_arrays_1_type() {
"inner_arrays_1",
json!({ "arg": [[[[0x13, 0x37]]]] })
);
assert_eq!(result3, right_result);
assert_eq!(result3, expected_result);
let result4 = call_faas!(
faas,
@ -541,7 +514,7 @@ pub fn inner_arrays_1_type() {
"inner_arrays_1",
json!([[[[[0x13, 0x37]]]]])
);
assert_eq!(result4, right_result);
assert_eq!(result4, expected_result);
}
#[test]
@ -565,7 +538,7 @@ pub fn inner_arrays_2_type() {
);
assert!(result2.is_err());
let right_result = json!([
let expected_result = json!([
[[[{
"field_0": 0,
"field_1": [[1]]
@ -605,7 +578,7 @@ pub fn inner_arrays_2_type() {
"inner_arrays_2",
json!({ "arg": [[[[[0, [[1]]]]]]] })
);
assert_eq!(result3, right_result);
assert_eq!(result3, expected_result);
let result4 = call_faas!(
faas,
@ -613,11 +586,10 @@ pub fn inner_arrays_2_type() {
"inner_arrays_2",
json!([[[[[{"field_0": 0, "field_1": [[1]]}]]]]])
);
assert_eq!(result4, right_result);
assert_eq!(result4, expected_result);
}
#[test]
#[ignore]
pub fn bool_type() {
let mut faas = FluenceFaaS::with_raw_config(ARG_CONFIG.clone())
.unwrap_or_else(|e| panic!("can't create Fluence FaaS instance: {}", e));
@ -638,18 +610,18 @@ pub fn bool_type() {
);
assert!(result2.is_err());
let right_result = json!(1);
let expected_result = json!([true, true, false, true, false, true]);
let result3 = call_faas!(
faas,
"arrays_passing_pure",
"bool_type",
json!({ "arg": 0 })
json!({ "arg": [false] })
);
assert_eq!(result3, right_result);
assert_eq!(result3, expected_result);
let result4 = call_faas!(faas, "arrays_passing_pure", "bool_type", json!(0));
assert_eq!(result4, right_result);
let result4 = call_faas!(faas, "arrays_passing_pure", "bool_type", json!([[false]]));
assert_eq!(result4, expected_result);
}
#[test]
@ -657,15 +629,15 @@ pub fn empty_type() {
let mut faas = FluenceFaaS::with_raw_config(ARG_CONFIG.clone())
.unwrap_or_else(|e| panic!("can't create Fluence FaaS instance: {}", e));
let right_result = json!(["from effector"]);
let expected_result = json!(["from effector"]);
let result1 = call_faas!(faas, "arrays_passing_pure", "empty_type", json!({}));
assert_eq!(result1, right_result);
assert_eq!(result1, expected_result);
let result2 = call_faas!(faas, "arrays_passing_pure", "empty_type", json!([]));
assert_eq!(result2, right_result);
assert_eq!(result2, expected_result);
let result3 = call_faas!(faas, "arrays_passing_pure", "empty_type", json!([]));
assert_eq!(result3, right_result);
assert_eq!(result3, expected_result);
let result4 = faas.call_with_json(
"arrays_passing_pure",