diff --git a/crates/fce-macro/Cargo.toml b/crates/fce-macro/Cargo.toml index d0997e3..9c78807 100644 --- a/crates/fce-macro/Cargo.toml +++ b/crates/fce-macro/Cargo.toml @@ -15,6 +15,7 @@ all-features = true [lib] proc-macro = true +doctest = false [dependencies] fluence-sdk-wit = { path = "../wit", version = "=0.5.0" } diff --git a/crates/fce-test-macro/Cargo.toml b/crates/fce-test-macro/Cargo.toml index eb15b83..c8578ca 100644 --- a/crates/fce-test-macro/Cargo.toml +++ b/crates/fce-test-macro/Cargo.toml @@ -14,6 +14,7 @@ all-features = true [lib] proc-macro = true +doctest = false [dependencies] fluence-sdk-test-macro-impl = { path = "../fce-test-macro-impl", version = "=0.5.0" } diff --git a/crates/main/Cargo.toml b/crates/main/Cargo.toml index abfdbcf..0ad43c8 100644 --- a/crates/main/Cargo.toml +++ b/crates/main/Cargo.toml @@ -16,6 +16,7 @@ all-features = true [lib] path = "src/lib.rs" crate-type = ["rlib"] +doctest = false [dependencies] fluence-sdk-macro = { path = "../fce-macro", version = "=0.5.0" } diff --git a/fluence-test/Cargo.toml b/fluence-test/Cargo.toml index 6359737..76c4596 100644 --- a/fluence-test/Cargo.toml +++ b/fluence-test/Cargo.toml @@ -16,6 +16,7 @@ all-features = true [lib] path = "src/lib.rs" +doctest = false [dependencies] fluence-sdk-test-macro = { path = "../crates/fce-test-macro", version = "=0.5.0" } diff --git a/fluence/Cargo.toml b/fluence/Cargo.toml index 6c45896..a8803f1 100644 --- a/fluence/Cargo.toml +++ b/fluence/Cargo.toml @@ -16,11 +16,15 @@ all-features = true [lib] path = "src/lib.rs" +doctest = false [dependencies] fluence-sdk-macro = { path = "../crates/fce-macro", version = "=0.5.0" } fluence-sdk-main = { path = "../crates/main", version = "=0.5.0" } +[dev-dependencies] +trybuild = "1.0" + [features] # Print some internal logs by log_utf8_string debug = ["fluence-sdk-main/debug"] diff --git a/fluence/tests/export_functions/arrays.rs b/fluence/tests/export_functions/arrays.rs new file mode 100644 index 0000000..2b9c7f4 --- /dev/null +++ b/fluence/tests/export_functions/arrays.rs @@ -0,0 +1,67 @@ +#![allow(improper_ctypes)] + +use fluence::fce; + +pub fn main() {} + +#[fce] +pub fn byte_type( __arg: Vec) -> Vec { + unimplemented!() +} + +#[fce] +pub fn inner_arrays_1(_arg: Vec>>>) -> Vec>>> { + unimplemented!() +} + +#[fce] +#[derive(Default)] +pub struct TestRecord { + pub field_0: i32, + pub field_1: Vec>, +} + +#[fce] +pub fn inner_arrays_2(_arg: Vec>>>) -> Vec>>> { + unimplemented!() +} + +#[fce] +pub fn string_type(_arg: Vec) -> Vec { + unimplemented!() +} + +#[fce] +pub fn f32_type(_arg: Vec) -> Vec { + unimplemented!() +} + +#[fce] +pub fn f64_type(_arg: Vec) -> Vec { + unimplemented!() +} + +#[fce] +pub fn u32_type(_arg: Vec) -> Vec { + unimplemented!() +} + +#[fce] +pub fn u64_type(_arg: Vec) -> Vec { + unimplemented!() +} + +#[fce] +pub fn i32_type(_arg: Vec) -> Vec { + unimplemented!() +} + +#[fce] +pub fn i64_type(_arg: Vec) -> Vec { + unimplemented!() +} + +#[fce] +pub fn empty_type() -> Vec { + unimplemented!() +} diff --git a/fluence/tests/export_functions/basic_types.rs b/fluence/tests/export_functions/basic_types.rs new file mode 100644 index 0000000..b0cd5fb --- /dev/null +++ b/fluence/tests/export_functions/basic_types.rs @@ -0,0 +1,73 @@ +#![allow(improper_ctypes)] + +use fluence::fce; + +pub fn main() {} + +#[fce] +pub fn all_types( + _arg_0: i8, + _arg_1: i16, + _arg_2: i32, + _arg_3: i64, + _arg_4: u8, + _arg_5: u16, + _arg_6: u32, + _arg_7: u64, + _arg_8: f32, + _arg_9: f64, + _arg_10: String, + _arg_11: Vec, +) -> Vec { + unimplemented!() +} + +#[fce] +pub fn string_type(_arg: String) -> String { + unimplemented!() +} + +#[fce] +pub fn bytearray_type(_arg: Vec) -> Vec { + unimplemented!() +} + +#[fce] +pub fn bool_type(_arg: bool) -> bool { + unimplemented!() +} + +#[fce] +pub fn f32_type(_arg: f32) -> f32 { + unimplemented!() +} + +#[fce] +pub fn f64_type(_arg: f64) -> f64 { + unimplemented!() +} + +#[fce] +pub fn u32_type(_arg: u32) -> u32 { + unimplemented!() +} + +#[fce] +pub fn u64_type(_arg: u64) -> u64 { + unimplemented!() +} + +#[fce] +pub fn i32_type(_arg: i32) -> i32 { + unimplemented!() +} + +#[fce] +pub fn i64_type(_arg: i64) -> i64 { + unimplemented!() +} + +#[fce] +pub fn empty_type() -> String { + unimplemented!() +} diff --git a/fluence/tests/export_functions/improper_types.rs b/fluence/tests/export_functions/improper_types.rs new file mode 100644 index 0000000..d2caa86 --- /dev/null +++ b/fluence/tests/export_functions/improper_types.rs @@ -0,0 +1,24 @@ +#![allow(improper_ctypes)] + +use fluence::fce; + +pub fn main() {} + +#[fce] +fn test(_arg_1: Box) {} + +#[fce] +fn test2(_arg_1: std::rc::Rc) {} + +#[fce] +fn test3(_arg_1: std::collections::HashMap) {} + +#[fce] +fn test4(_arg_1: i32) -> (i32, i32) { + unimplemented!() +} + +#[fce] +fn test5(_arg_1: i32) -> Box { + unimplemented!() +} diff --git a/fluence/tests/export_functions/improper_types.stderr b/fluence/tests/export_functions/improper_types.stderr new file mode 100644 index 0000000..a77fcc0 --- /dev/null +++ b/fluence/tests/export_functions/improper_types.stderr @@ -0,0 +1,29 @@ +error: type with lifetimes or generics aren't allowed + --> $DIR/improper_types.rs:8:17 + | +8 | fn test(_arg_1: Box) {} + | ^^^^^^^^ + +error: type with lifetimes or generics aren't allowed + --> $DIR/improper_types.rs:11:27 + | +11 | fn test2(_arg_1: std::rc::Rc) {} + | ^^^^^^^ + +error: type with lifetimes or generics aren't allowed + --> $DIR/improper_types.rs:14:36 + | +14 | fn test3(_arg_1: std::collections::HashMap) {} + | ^^^^^^^^^^^^^^^^^^^^ + +error: Incorrect argument type - passing only by value is supported now + --> $DIR/improper_types.rs:17:26 + | +17 | fn test4(_arg_1: i32) -> (i32, i32) { + | ^^^^^^^^^^ + +error: type with lifetimes or generics aren't allowed + --> $DIR/improper_types.rs:22:26 + | +22 | fn test5(_arg_1: i32) -> Box { + | ^^^^^^^^ diff --git a/fluence/tests/import_functions/arrays.rs b/fluence/tests/import_functions/arrays.rs new file mode 100644 index 0000000..052a884 --- /dev/null +++ b/fluence/tests/import_functions/arrays.rs @@ -0,0 +1,40 @@ +#![allow(improper_ctypes)] + +use fluence::fce; + +pub fn main() {} + +#[fce] +#[derive(Default)] +pub struct TestRecord { + pub field_0: i32, + pub field_1: Vec>, +} + +#[fce] +#[link(wasm_import_module = "arrays_passing_effector")] +extern "C" { + pub fn inner_arrays_1(arg: Vec>>>) -> Vec>>>; + + pub fn inner_arrays_2( + arg: Vec>>>, + ) -> Vec>>>; + + pub fn string_type(arg: Vec) -> Vec; + + pub fn byte_type(arg: Vec) -> Vec; + + pub fn f32_type(arg: Vec) -> Vec; + + pub fn f64_type(arg: Vec) -> Vec; + + pub fn u32_type(arg: Vec) -> Vec; + + pub fn u64_type(arg: Vec) -> Vec; + + pub fn i32_type(arg: Vec) -> Vec; + + pub fn i64_type(arg: Vec) -> Vec; + + pub fn empty_type() -> Vec; +} diff --git a/fluence/tests/import_functions/basic_types.rs b/fluence/tests/import_functions/basic_types.rs new file mode 100644 index 0000000..340a5d2 --- /dev/null +++ b/fluence/tests/import_functions/basic_types.rs @@ -0,0 +1,40 @@ +#![allow(improper_ctypes)] + +use fluence::fce; + +fn main() {} + +#[fce] +#[link(wasm_import_module = "arguments_passing_effector")] +extern "C" { + pub fn all_types( + arg_0: i8, + arg_1: i16, + arg_2: i32, + arg_3: i64, + arg_4: u8, + arg_5: u16, + arg_6: u32, + arg_7: u64, + arg_8: f32, + arg_9: f64, + arg_10: String, + arg_11: Vec, + ) -> Vec; + + pub fn string_type(arg: String) -> String; + pub fn bytearray_type(arg: Vec) -> Vec; + + pub fn bool_type(arg: bool) -> bool; + + pub fn f32_type(arg: f32) -> f32; + pub fn f64_type(arg: f64) -> f64; + + pub fn u32_type(arg: u32) -> u32; + pub fn u64_type(arg: u64) -> u64; + + pub fn i32_type(arg: i32) -> i32; + pub fn i64_type(arg: i64) -> i64; + + pub fn empty_type() -> String; +} diff --git a/fluence/tests/import_functions/improper_types.rs b/fluence/tests/import_functions/improper_types.rs new file mode 100644 index 0000000..5888828 --- /dev/null +++ b/fluence/tests/import_functions/improper_types.rs @@ -0,0 +1,24 @@ +#![allow(improper_ctypes)] + +use fluence::fce; + +pub fn main() {} + +#[fce] +#[link(wasm_import_module = "arguments_passing_effector")] +extern "C" { + #[fce] + fn test(_arg_1: Box); + + #[fce] + fn test2(_arg_1: std::rc::Rc); + + #[fce] + fn test3(_arg_1: std::collections::HashMap); + + #[fce] + fn test4(_arg_1: i32) -> (i32, i32); + + #[fce] + fn test5(_arg_1: i32) -> Box; +} diff --git a/fluence/tests/import_functions/improper_types.stderr b/fluence/tests/import_functions/improper_types.stderr new file mode 100644 index 0000000..6879314 --- /dev/null +++ b/fluence/tests/import_functions/improper_types.stderr @@ -0,0 +1,5 @@ +error: type with lifetimes or generics aren't allowed + --> $DIR/improper_types.rs:11:21 + | +11 | fn test(_arg_1: Box); + | ^^^^^^^^ diff --git a/fluence/tests/records/basic_structs.rs b/fluence/tests/records/basic_structs.rs new file mode 100644 index 0000000..34d8b79 --- /dev/null +++ b/fluence/tests/records/basic_structs.rs @@ -0,0 +1,82 @@ +#![allow(improper_ctypes)] + +use fluence::fce; + +fn main() {} + +#[fce] +pub struct TestRecord { + pub field_0: bool, + pub field_1: i8, + pub field_2: i16, + pub field_3: i32, + pub field_4: i64, + pub field_5: u8, + pub field_6: u16, + pub field_7: u32, + pub field_8: u64, + pub field_9: f32, + pub field_10: f64, + pub field_11: String, + pub field_12: Vec, +} + +#[fce] +pub struct Tx { + pub block_hash: String, + pub block_number: String, + pub from: String, + pub gas: String, + pub gas_price: String, + pub hash: String, + pub input: String, + pub nonce: String, + pub to: String, + pub transaction_index: String, + pub value: String, +} + +#[fce] +#[derive(Debug)] +pub struct JsonRpcResult { + pub json_rpc: String, + pub result: String, + pub error: String, + pub id: u64, +} + +#[fce] +#[derive(Clone, Debug, Default, Eq, PartialEq, Hash)] +pub struct User { + pub peer_id: String, + pub relay_id: String, + pub signature: String, + pub name: String, +} + +#[fce] +pub struct GetUsersServiceResult { + pub ret_code: i32, + pub err_msg: String, + pub users: Vec, +} + +#[fce] +pub struct EmptyServiceResult { + pub ret_code: i32, + pub err_msg: String, +} + +#[fce] +pub struct ExistsServiceResult { + pub ret_code: i32, + pub err_msg: String, + pub is_exists: bool, +} + +#[fce] +pub struct AuthResult { + pub ret_code: i32, + pub err_msg: String, + pub is_authenticated: bool, +} diff --git a/fluence/tests/records/empty_struct.rs b/fluence/tests/records/empty_struct.rs new file mode 100644 index 0000000..7a8bce1 --- /dev/null +++ b/fluence/tests/records/empty_struct.rs @@ -0,0 +1,8 @@ +#![allow(improper_ctypes)] + +use fluence::fce; + +fn main() {} + +#[fce] +struct A {} diff --git a/fluence/tests/records/struct_with_improper_types.rs b/fluence/tests/records/struct_with_improper_types.rs new file mode 100644 index 0000000..40889a4 --- /dev/null +++ b/fluence/tests/records/struct_with_improper_types.rs @@ -0,0 +1,20 @@ +#![allow(improper_ctypes)] + +use fluence::fce; + +fn main() {} + +#[fce] +struct StructWithBox { + pub a: Box, +} + +#[fce] +struct StructWithRc { + pub a: std::rc::Rc, +} + +#[fce] +struct StructWithHashMap { + pub a: std::collections::HashMap, +} diff --git a/fluence/tests/records/struct_with_improper_types.stderr b/fluence/tests/records/struct_with_improper_types.stderr new file mode 100644 index 0000000..8275e88 --- /dev/null +++ b/fluence/tests/records/struct_with_improper_types.stderr @@ -0,0 +1,17 @@ +error: type with lifetimes or generics aren't allowed + --> $DIR/struct_with_improper_types.rs:9:12 + | +9 | pub a: Box, + | ^^^^^^^^ + +error: type with lifetimes or generics aren't allowed + --> $DIR/struct_with_improper_types.rs:14:21 + | +14 | pub a: std::rc::Rc, + | ^^^^^^^ + +error: type with lifetimes or generics aren't allowed + --> $DIR/struct_with_improper_types.rs:19:30 + | +19 | pub a: std::collections::HashMap, + | ^^^^^^^^^^^^^^^^^^^^ diff --git a/fluence/tests/records/struct_with_private_fields.rs b/fluence/tests/records/struct_with_private_fields.rs new file mode 100644 index 0000000..ca4f2aa --- /dev/null +++ b/fluence/tests/records/struct_with_private_fields.rs @@ -0,0 +1,11 @@ +#![allow(improper_ctypes)] + +use fluence::fce; + +fn main() {} + +#[fce] +struct StructWithPrivateFields { + a: i32, + b: usize, +} diff --git a/fluence/tests/records/struct_with_private_fields.stderr b/fluence/tests/records/struct_with_private_fields.stderr new file mode 100644 index 0000000..22b2d15 --- /dev/null +++ b/fluence/tests/records/struct_with_private_fields.stderr @@ -0,0 +1,5 @@ +error: #[fce] could be applied only to struct with all public fields + --> $DIR/struct_with_private_fields.rs:9:5 + | +9 | a: i32, + | ^^^^^^ diff --git a/fluence/tests/test_runner.rs b/fluence/tests/test_runner.rs new file mode 100644 index 0000000..ff32c6d --- /dev/null +++ b/fluence/tests/test_runner.rs @@ -0,0 +1,16 @@ +#[test] +fn test() { + let tests = trybuild::TestCases::new(); + tests.pass("tests/export_functions/arrays.rs"); + tests.pass("tests/export_functions/basic_types.rs"); + tests.compile_fail("tests/export_functions/improper_types.rs"); + + tests.pass("tests/import_functions/arrays.rs"); + tests.pass("tests/import_functions/basic_types.rs"); + tests.compile_fail("tests/import_functions/improper_types.rs"); + + tests.pass("tests/records/basic_structs.rs"); + tests.pass("tests/records/empty_struct.rs"); + tests.compile_fail("tests/records/struct_with_improper_types.rs"); + tests.compile_fail("tests/records/struct_with_private_fields.rs"); +} diff --git a/tests/test_files/arrays_passing.rs b/tests/test_files/arrays_passing.rs deleted file mode 100644 index b60b122..0000000 --- a/tests/test_files/arrays_passing.rs +++ /dev/null @@ -1,175 +0,0 @@ -use fluence::fce; - -pub fn main() {} - -#[fce] -pub fn byte_type(mut arg: Vec) -> Vec { - arg.push(0); - - let mut arg = unsafe { effector::byte_type(arg) }; - - arg.push(2); - arg -} - -#[fce] -pub fn inner_arrays_1(mut arg: Vec>>>) -> Vec>>> { - arg.push(vec![vec![vec![0]]]); - - let mut arg = unsafe { effector::inner_arrays_1(arg) }; - - arg.push(vec![vec![vec![2]]]); - arg -} - -#[fce] -#[derive(Default)] -pub struct TestRecord { - pub field_0: i32, - pub field_1: Vec>, -} - -#[fce] -pub fn inner_arrays_2(mut arg: Vec>>>) -> Vec>>> { - arg.push(vec![vec![vec![ - TestRecord { - field_0: 0, - field_1: vec![vec![1]], - }, - TestRecord::default(), - ]]]); - - let mut arg = unsafe { effector::inner_arrays_2(arg) }; - - arg.push(vec![vec![vec![ - TestRecord { - field_0: 1, - field_1: vec![vec![2]], - }, - TestRecord::default(), - ]]]); - - arg -} - -#[fce] -pub fn string_type(mut arg: Vec) -> Vec { - arg.push(String::from("fce")); - - let mut arg = unsafe { effector::string_type(arg) }; - - arg.push(String::from("test")); - arg -} - -/* -#[fce] -pub fn bool_type(arg: Vec) -> Vec { - let mut arg = unsafe { effector::bool_type(arg) }; - - arg.push(false); - arg -} - */ - -#[fce] -pub fn f32_type(mut arg: Vec) -> Vec { - arg.push(0.0); - - let mut arg = unsafe { effector::f32_type(arg) }; - - arg.push(1.0); - arg -} - -#[fce] -pub fn f64_type(mut arg: Vec) -> Vec { - arg.push(0.0); - - let mut arg = unsafe { effector::f64_type(arg) }; - - arg.push(1.0); - arg -} - -#[fce] -pub fn u32_type(mut arg: Vec) -> Vec { - arg.push(0); - - let mut arg = unsafe { effector::u32_type(arg) }; - - arg.push(2); - arg -} - -#[fce] -pub fn u64_type(mut arg: Vec) -> Vec { - arg.push(0); - - let mut arg = unsafe { effector::u64_type(arg) }; - - arg.push(2); - arg -} - -#[fce] -pub fn i32_type(mut arg: Vec) -> Vec { - arg.push(0); - - let mut arg = unsafe { effector::i32_type(arg) }; - - arg.push(2); - arg -} - -#[fce] -pub fn i64_type(mut arg: Vec) -> Vec { - arg.push(0); - - let mut arg = unsafe { effector::i64_type(arg) }; - - arg.push(1); - arg -} - -#[fce] -pub fn empty_type() -> Vec { - unsafe { effector::empty_type() } -} - -mod effector { - use fluence::fce; - use super::TestRecord; - - #[fce] - #[link(wasm_import_module = "arrays_passing_effector")] - extern "C" { - pub fn inner_arrays_1(arg: Vec>>>) -> Vec>>>; - - pub fn inner_arrays_2( - arg: Vec>>>, - ) -> Vec>>>; - - pub fn string_type(arg: Vec) -> Vec; - - pub fn byte_type(arg: Vec) -> Vec; - - /* - pub fn bool_type(arg: Vec) -> Vec; - */ - - pub fn f32_type(arg: Vec) -> Vec; - - pub fn f64_type(arg: Vec) -> Vec; - - pub fn u32_type(arg: Vec) -> Vec; - - pub fn u64_type(arg: Vec) -> Vec; - - pub fn i32_type(arg: Vec) -> Vec; - - pub fn i64_type(arg: Vec) -> Vec; - - pub fn empty_type() -> Vec; - } -} diff --git a/tests/test_files/basic_argument_passing.rs b/tests/test_files/basic_argument_passing.rs deleted file mode 100644 index beed225..0000000 --- a/tests/test_files/basic_argument_passing.rs +++ /dev/null @@ -1,153 +0,0 @@ -#![allow(improper_ctypes)] - -use fluence::fce; - -pub fn main() {} - -#[fce] -pub fn all_types( - arg_0: i8, - arg_1: i16, - arg_2: i32, - arg_3: i64, - arg_4: u8, - arg_5: u16, - arg_6: u32, - arg_7: u64, - arg_8: f32, - arg_9: f64, - arg_10: String, - arg_11: Vec, -) -> Vec { - let mut result = unsafe { - effector::all_types( - arg_0, - arg_1, - arg_2, - arg_3, - arg_4, - arg_5, - arg_6, - arg_7, - arg_8, - arg_9, - arg_10.clone(), - arg_11.clone(), - ) - }; - - result.push(arg_0 as u8); - result.extend(safe_transmute::transmute_one_to_bytes(&arg_1)); - result.extend(safe_transmute::transmute_one_to_bytes(&arg_2)); - result.extend(safe_transmute::transmute_one_to_bytes(&arg_3)); - result.extend(safe_transmute::transmute_one_to_bytes(&arg_4)); - result.extend(safe_transmute::transmute_one_to_bytes(&arg_5)); - result.extend(safe_transmute::transmute_one_to_bytes(&arg_6)); - result.extend(safe_transmute::transmute_one_to_bytes(&arg_7)); - result.extend(&arg_8.to_be_bytes()); - result.extend(&arg_9.to_be_bytes()); - result.extend(arg_10.into_bytes()); - result.extend(arg_11); - - result -} - -#[fce] -pub fn string_type(arg: String) -> String { - let arg = unsafe { effector::string_type(arg) }; - - format!("{}_{}", arg, arg) -} - -#[fce] -pub fn bytearray_type(arg: Vec) -> Vec { - let mut arg = unsafe { effector::bytearray_type(arg) }; - - arg.push(1); - arg -} - -#[fce] -pub fn bool_type(arg: bool) -> bool { - unsafe { effector::bool_type(arg) } -} - -#[fce] -pub fn f32_type(arg: f32) -> f32 { - let arg = unsafe { effector::f32_type(arg) }; - arg + 1.0 -} - -#[fce] -pub fn f64_type(arg: f64) -> f64 { - let arg = unsafe { effector::f64_type(arg) }; - arg + 1.0 -} - -#[fce] -pub fn u32_type(arg: u32) -> u32 { - let arg = unsafe { effector::u32_type(arg) }; - arg + 1 -} - -#[fce] -pub fn u64_type(arg: u64) -> u64 { - let arg = unsafe { effector::u64_type(arg) }; - arg + 1 -} - -#[fce] -pub fn i32_type(arg: i32) -> i32 { - let arg = unsafe { effector::i32_type(arg) }; - arg + 1 -} - -#[fce] -pub fn i64_type(arg: i64) -> i64 { - let arg = unsafe { effector::i64_type(arg) }; - arg + 1 -} - -#[fce] -pub fn empty_type() -> String { - unsafe { effector::empty_type() } -} - -mod effector { - use fluence::fce; - - #[fce] - #[link(wasm_import_module = "arguments_passing_effector")] - extern "C" { - pub fn all_types( - arg_0: i8, - arg_1: i16, - arg_2: i32, - arg_3: i64, - arg_4: u8, - arg_5: u16, - arg_6: u32, - arg_7: u64, - arg_8: f32, - arg_9: f64, - arg_10: String, - arg_11: Vec, - ) -> Vec; - - pub fn string_type(arg: String) -> String; - pub fn bytearray_type(arg: Vec) -> Vec; - - pub fn bool_type(arg: bool) -> bool; - - pub fn f32_type(arg: f32) -> f32; - pub fn f64_type(arg: f64) -> f64; - - pub fn u32_type(arg: u32) -> u32; - pub fn u64_type(arg: u64) -> u64; - - pub fn i32_type(arg: i32) -> i32; - pub fn i64_type(arg: i64) -> i64; - - pub fn empty_type() -> String; - } -} diff --git a/tests/test_files/records.rs b/tests/test_files/records.rs deleted file mode 100644 index e69de29..0000000