diff --git a/compiler/tests/address/mod.rs b/compiler/tests/address/mod.rs index 3d892a5fb7..eb93b660f9 100644 --- a/compiler/tests/address/mod.rs +++ b/compiler/tests/address/mod.rs @@ -22,72 +22,72 @@ static TEST_ADDRESS_2: &str = "aleo18qgam03qe483tdrcc3fkqwpp38ehff4a2xma6lu7hams #[test] fn test_valid() { - let bytes = include_bytes!("valid.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("valid.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program) } #[test] fn test_invalid_prefix() { - let bytes = include_bytes!("invalid_prefix.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("invalid_prefix.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_invalid_length() { - let bytes = include_bytes!("invalid_length.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("invalid_length.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_empty() { - let bytes = include_bytes!("empty.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("empty.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_implicit_valid() { - let bytes = include_bytes!("implicit_valid.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("implicit_valid.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_implicit_invalid() { - let bytes = include_bytes!("implicit_invalid.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("implicit_invalid.leo"); + let program = parse_program(program_string).unwrap(); let _output = expect_compiler_error(program); } #[test] fn test_console_assert_pass() { - let bytes = include_bytes!("console_assert_pass.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("console_assert_pass.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_console_assert_fail() { - let bytes = include_bytes!("console_assert_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("console_assert_fail.leo"); + let program = parse_program(program_string).unwrap(); let _output = expect_compiler_error(program); } #[test] fn test_ternary() { - let bytes = include_bytes!("ternary.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("ternary.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("s", Some(InputValue::Boolean(true))), @@ -98,7 +98,7 @@ fn test_ternary() { assert_satisfied(program); - let mut program = parse_program(bytes).unwrap(); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("s", Some(InputValue::Boolean(false))), @@ -112,8 +112,8 @@ fn test_ternary() { #[test] fn test_equal() { - let bytes = include_bytes!("equal.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("equal.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Address(TEST_ADDRESS_1.to_string()))), @@ -125,7 +125,7 @@ fn test_equal() { assert_satisfied(program); - let mut program = parse_program(bytes).unwrap(); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Address(TEST_ADDRESS_1.to_string()))), diff --git a/compiler/tests/array/mod.rs b/compiler/tests/array/mod.rs index c26c21edc6..6d4684ad18 100644 --- a/compiler/tests/array/mod.rs +++ b/compiler/tests/array/mod.rs @@ -69,8 +69,8 @@ fn test_inline() { #[test] fn test_inline_fail() { - let program_bytes = include_bytes!("inline.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("inline.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } @@ -149,64 +149,64 @@ fn test_input_tuple_3x2_fail() { #[test] fn test_multi_fail_initializer() { - let program_bytes = include_bytes!("multi_fail_initializer.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("multi_fail_initializer.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_multi_inline_fail() { - let program_bytes = include_bytes!("multi_fail_inline.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("multi_fail_inline.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_multi_initializer() { - let program_bytes = include_bytes!("multi_initializer.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("multi_initializer.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_multi_initializer_fail() { - let program_bytes = include_bytes!("multi_initializer_fail.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("multi_initializer_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_nested_3x2_value() { - let program_bytes = include_bytes!("nested_3x2_value.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("nested_3x2_value.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_nested_3x2_value_fail() { - let program_bytes = include_bytes!("nested_3x2_value_fail.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("nested_3x2_value_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_tuple_3x2_value() { - let program_bytes = include_bytes!("tuple_3x2_value.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("tuple_3x2_value.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_tuple_3x2_value_fail() { - let program_bytes = include_bytes!("tuple_3x2_value_fail.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("tuple_3x2_value_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } @@ -233,136 +233,136 @@ fn test_slice() { #[test] fn test_type_fail() { - let program_bytes = include_bytes!("type_fail.leo"); - let syntax_error = parse_program(program_bytes).is_err(); + let program_string = include_str!("type_fail.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_type_nested_value_nested_3x2() { - let program_bytes = include_bytes!("type_nested_value_nested_3x2.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_nested_value_nested_3x2.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_type_nested_value_nested_3x2_fail() { - let program_bytes = include_bytes!("type_nested_value_nested_3x2_fail.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_nested_value_nested_3x2_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_type_nested_value_nested_4x3x2() { - let program_bytes = include_bytes!("type_nested_value_nested_4x3x2.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_nested_value_nested_4x3x2.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_type_nested_value_nested_4x3x2_fail() { - let program_bytes = include_bytes!("type_nested_value_nested_4x3x2_fail.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_nested_value_nested_4x3x2_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_type_nested_value_tuple_3x2() { - let program_bytes = include_bytes!("type_nested_value_tuple_3x2.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_nested_value_tuple_3x2.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_type_nested_value_tuple_3x2_fail() { - let program_bytes = include_bytes!("type_nested_value_tuple_3x2_fail.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_nested_value_tuple_3x2_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_type_nested_value_tuple_4x3x2() { - let program_bytes = include_bytes!("type_nested_value_tuple_4x3x2.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_nested_value_tuple_4x3x2.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_type_nested_value_tuple_4x3x2_fail() { - let program_bytes = include_bytes!("type_nested_value_tuple_4x3x2_fail.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_nested_value_tuple_4x3x2_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_type_tuple_value_nested_3x2() { - let program_bytes = include_bytes!("type_tuple_value_nested_3x2.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_tuple_value_nested_3x2.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_type_tuple_value_nested_3x2_fail() { - let program_bytes = include_bytes!("type_tuple_value_nested_3x2_fail.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_tuple_value_nested_3x2_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_type_tuple_value_nested_4x3x2() { - let program_bytes = include_bytes!("type_tuple_value_nested_4x3x2.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_tuple_value_nested_4x3x2.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_type_tuple_value_nested_4x3x2_fail() { - let program_bytes = include_bytes!("type_tuple_value_nested_4x3x2_fail.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_tuple_value_nested_4x3x2_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_type_tuple_value_tuple_3x2() { - let program_bytes = include_bytes!("type_tuple_value_tuple_3x2.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_tuple_value_tuple_3x2.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_type_tuple_value_tuple_3x2_fail() { - let program_bytes = include_bytes!("type_tuple_value_tuple_3x2_fail.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_tuple_value_tuple_3x2_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_type_tuple_value_tuple_4x3x2() { - let program_bytes = include_bytes!("type_tuple_value_tuple_4x3x2.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_tuple_value_tuple_4x3x2.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_type_tuple_value_tuple_4x3x2_fail() { - let program_bytes = include_bytes!("type_tuple_value_tuple_4x3x2_fail.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("type_tuple_value_tuple_4x3x2_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } diff --git a/compiler/tests/boolean/mod.rs b/compiler/tests/boolean/mod.rs index 175ebce138..d71ff3def0 100644 --- a/compiler/tests/boolean/mod.rs +++ b/compiler/tests/boolean/mod.rs @@ -79,7 +79,7 @@ fn test_registers() { #[test] fn test_not_true() { - let bytes = include_bytes!("not_true.leo"); + let bytes = include_str!("not_true.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -87,7 +87,7 @@ fn test_not_true() { #[test] fn test_not_false() { - let bytes = include_bytes!("not_false.leo"); + let bytes = include_str!("not_false.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -95,7 +95,7 @@ fn test_not_false() { #[test] fn test_not_mutable() { - let bytes = include_bytes!("not_mutable.leo"); + let bytes = include_str!("not_mutable.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -103,7 +103,7 @@ fn test_not_mutable() { #[test] fn test_not_u32() { - let bytes = include_bytes!("not_u32.leo"); + let bytes = include_str!("not_u32.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -113,7 +113,7 @@ fn test_not_u32() { #[test] fn test_true_or_true() { - let bytes = include_bytes!("true_or_true.leo"); + let bytes = include_str!("true_or_true.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -121,7 +121,7 @@ fn test_true_or_true() { #[test] fn test_true_or_false() { - let bytes = include_bytes!("true_or_false.leo"); + let bytes = include_str!("true_or_false.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -129,7 +129,7 @@ fn test_true_or_false() { #[test] fn test_false_or_false() { - let bytes = include_bytes!("false_or_false.leo"); + let bytes = include_str!("false_or_false.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -137,7 +137,7 @@ fn test_false_or_false() { #[test] fn test_true_or_u32() { - let bytes = include_bytes!("true_or_u32.leo"); + let bytes = include_str!("true_or_u32.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -147,7 +147,7 @@ fn test_true_or_u32() { #[test] fn test_true_and_true() { - let bytes = include_bytes!("true_and_true.leo"); + let bytes = include_str!("true_and_true.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -155,7 +155,7 @@ fn test_true_and_true() { #[test] fn test_true_and_false() { - let bytes = include_bytes!("true_and_false.leo"); + let bytes = include_str!("true_and_false.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -163,7 +163,7 @@ fn test_true_and_false() { #[test] fn test_false_and_false() { - let bytes = include_bytes!("false_and_false.leo"); + let bytes = include_str!("false_and_false.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -171,7 +171,7 @@ fn test_false_and_false() { #[test] fn test_true_and_u32() { - let bytes = include_bytes!("true_and_u32.leo"); + let bytes = include_str!("true_and_u32.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -181,7 +181,7 @@ fn test_true_and_u32() { #[test] fn test_all() { - let bytes = include_bytes!("all.leo"); + let bytes = include_str!("all.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); diff --git a/compiler/tests/circuits/mod.rs b/compiler/tests/circuits/mod.rs index 33d0d41ea9..4bfdcdac34 100644 --- a/compiler/tests/circuits/mod.rs +++ b/compiler/tests/circuits/mod.rs @@ -20,7 +20,7 @@ use crate::{assert_satisfied, expect_compiler_error, expect_type_inference_error #[test] fn test_inline() { - let bytes = include_bytes!("inline.leo"); + let bytes = include_str!("inline.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -28,7 +28,7 @@ fn test_inline() { #[test] fn test_inline_fail() { - let bytes = include_bytes!("inline_fail.leo"); + let bytes = include_str!("inline_fail.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -36,7 +36,7 @@ fn test_inline_fail() { #[test] fn test_inline_undefined() { - let bytes = include_bytes!("inline_undefined.leo"); + let bytes = include_str!("inline_undefined.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -46,7 +46,7 @@ fn test_inline_undefined() { #[test] fn test_member_variable() { - let bytes = include_bytes!("member_variable.leo"); + let bytes = include_str!("member_variable.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -54,7 +54,7 @@ fn test_member_variable() { #[test] fn test_member_variable_fail() { - let bytes = include_bytes!("member_variable_fail.leo"); + let bytes = include_str!("member_variable_fail.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -62,7 +62,7 @@ fn test_member_variable_fail() { #[test] fn test_member_variable_and_function() { - let bytes = include_bytes!("member_variable_and_function.leo"); + let bytes = include_str!("member_variable_and_function.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -70,7 +70,7 @@ fn test_member_variable_and_function() { #[test] fn test_member_function() { - let bytes = include_bytes!("member_function.leo"); + let bytes = include_str!("member_function.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -78,7 +78,7 @@ fn test_member_function() { #[test] fn test_member_function_fail() { - let bytes = include_bytes!("member_function_fail.leo"); + let bytes = include_str!("member_function_fail.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -86,7 +86,7 @@ fn test_member_function_fail() { #[test] fn test_member_function_invalid() { - let bytes = include_bytes!("member_function_invalid.leo"); + let bytes = include_str!("member_function_invalid.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -94,7 +94,7 @@ fn test_member_function_invalid() { #[test] fn test_member_function_nested() { - let bytes = include_bytes!("member_function_nested.leo"); + let bytes = include_str!("member_function_nested.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -102,7 +102,7 @@ fn test_member_function_nested() { #[test] fn test_member_static_function() { - let bytes = include_bytes!("member_static_function.leo"); + let bytes = include_str!("member_static_function.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -110,7 +110,7 @@ fn test_member_static_function() { #[test] fn test_member_static_function_nested() { - let bytes = include_bytes!("member_static_function_nested.leo"); + let bytes = include_str!("member_static_function_nested.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -118,7 +118,7 @@ fn test_member_static_function_nested() { #[test] fn test_member_static_function_invalid() { - let bytes = include_bytes!("member_static_function_invalid.leo"); + let bytes = include_str!("member_static_function_invalid.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error) @@ -126,7 +126,7 @@ fn test_member_static_function_invalid() { #[test] fn test_member_static_function_undefined() { - let bytes = include_bytes!("member_static_function_undefined.leo"); + let bytes = include_str!("member_static_function_undefined.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error) @@ -136,7 +136,7 @@ fn test_member_static_function_undefined() { #[test] fn test_mutate_function_fail() { - let bytes = include_bytes!("mut_function_fail.leo"); + let bytes = include_str!("mut_function_fail.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -144,7 +144,7 @@ fn test_mutate_function_fail() { #[test] fn test_mutate_self_variable() { - let bytes = include_bytes!("mut_self_variable.leo"); + let bytes = include_str!("mut_self_variable.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -152,7 +152,7 @@ fn test_mutate_self_variable() { #[test] fn test_mutate_self_variable_fail() { - let bytes = include_bytes!("mut_self_variable_fail.leo"); + let bytes = include_str!("mut_self_variable_fail.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -160,7 +160,7 @@ fn test_mutate_self_variable_fail() { #[test] fn test_mutate_self_function_fail() { - let bytes = include_bytes!("mut_self_function_fail.leo"); + let bytes = include_str!("mut_self_function_fail.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -168,7 +168,7 @@ fn test_mutate_self_function_fail() { #[test] fn test_mutate_self_static_function_fail() { - let bytes = include_bytes!("mut_self_static_function_fail.leo"); + let bytes = include_str!("mut_self_static_function_fail.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -176,7 +176,7 @@ fn test_mutate_self_static_function_fail() { #[test] fn test_mutate_static_function_fail() { - let bytes = include_bytes!("mut_static_function_fail.leo"); + let bytes = include_str!("mut_static_function_fail.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -184,7 +184,7 @@ fn test_mutate_static_function_fail() { #[test] fn test_mutate_variable() { - let bytes = include_bytes!("mut_variable.leo"); + let bytes = include_str!("mut_variable.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -192,7 +192,7 @@ fn test_mutate_variable() { #[test] fn test_mutate_variable_fail() { - let bytes = include_bytes!("mut_variable_fail.leo"); + let bytes = include_str!("mut_variable_fail.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -202,7 +202,7 @@ fn test_mutate_variable_fail() { #[test] fn test_self_fail() { - let bytes = include_bytes!("self_fail.leo"); + let bytes = include_str!("self_fail.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -210,7 +210,7 @@ fn test_self_fail() { #[test] fn test_self_member_pass() { - let bytes = include_bytes!("self_member.leo"); + let bytes = include_str!("self_member.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -218,7 +218,7 @@ fn test_self_member_pass() { #[test] fn test_self_member_invalid() { - let bytes = include_bytes!("self_member_invalid.leo"); + let bytes = include_str!("self_member_invalid.leo"); let program = parse_program(bytes).unwrap(); let _err = expect_compiler_error(program); @@ -226,7 +226,7 @@ fn test_self_member_invalid() { #[test] fn test_self_member_undefined() { - let bytes = include_bytes!("self_member_undefined.leo"); + let bytes = include_str!("self_member_undefined.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -236,7 +236,7 @@ fn test_self_member_undefined() { #[test] fn test_pedersen_mock() { - let bytes = include_bytes!("pedersen_mock.leo"); + let bytes = include_str!("pedersen_mock.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -244,7 +244,7 @@ fn test_pedersen_mock() { #[test] fn test_define_circuit_inside_circuit_function() { - let bytes = include_bytes!("define_circuit_inside_circuit_function.leo"); + let bytes = include_str!("define_circuit_inside_circuit_function.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); diff --git a/compiler/tests/console/mod.rs b/compiler/tests/console/mod.rs index ba7c48aae9..9bf1f820df 100644 --- a/compiler/tests/console/mod.rs +++ b/compiler/tests/console/mod.rs @@ -19,7 +19,7 @@ use leo_ast::InputValue; #[test] fn test_log() { - let bytes = include_bytes!("log.leo"); + let bytes = include_str!("log.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -27,14 +27,14 @@ fn test_log() { #[test] fn test_log_fail() { - let bytes = include_bytes!("log_fail.leo"); + let bytes = include_str!("log_fail.leo"); assert!(parse_program(bytes).is_err()); } #[test] fn test_log_parameter() { - let bytes = include_bytes!("log_parameter.leo"); + let bytes = include_str!("log_parameter.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -42,7 +42,7 @@ fn test_log_parameter() { #[test] fn test_log_parameter_many() { - let bytes = include_bytes!("log_parameter_many.leo"); + let bytes = include_str!("log_parameter_many.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -50,7 +50,7 @@ fn test_log_parameter_many() { #[test] fn test_log_parameter_fail_unknown() { - let bytes = include_bytes!("log_parameter_fail_unknown.leo"); + let bytes = include_str!("log_parameter_fail_unknown.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -58,7 +58,7 @@ fn test_log_parameter_fail_unknown() { #[test] fn test_log_parameter_fail_empty() { - let bytes = include_bytes!("log_parameter_fail_empty.leo"); + let bytes = include_str!("log_parameter_fail_empty.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -66,7 +66,7 @@ fn test_log_parameter_fail_empty() { #[test] fn test_log_parameter_fail_none() { - let bytes = include_bytes!("log_parameter_fail_empty.leo"); + let bytes = include_str!("log_parameter_fail_empty.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -74,7 +74,7 @@ fn test_log_parameter_fail_none() { #[test] fn test_log_input() { - let bytes = include_bytes!("log_input.leo"); + let bytes = include_str!("log_input.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]); @@ -88,7 +88,7 @@ fn test_log_input() { #[test] fn test_debug() { - let bytes = include_bytes!("debug.leo"); + let bytes = include_str!("debug.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -98,7 +98,7 @@ fn test_debug() { #[test] fn test_error() { - let bytes = include_bytes!("error.leo"); + let bytes = include_str!("error.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -108,7 +108,7 @@ fn test_error() { #[test] fn test_assert() { - let bytes = include_bytes!("assert.leo"); + let bytes = include_str!("assert.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]); @@ -128,7 +128,7 @@ fn test_assert() { #[test] fn test_conditional_assert() { - let bytes = include_bytes!("conditional_assert.leo"); + let bytes = include_str!("conditional_assert.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]); diff --git a/compiler/tests/core/mod.rs b/compiler/tests/core/mod.rs index 20943b7c36..293b84f536 100644 --- a/compiler/tests/core/mod.rs +++ b/compiler/tests/core/mod.rs @@ -20,7 +20,7 @@ use crate::{assert_satisfied, expect_symbol_table_error, parse_program}; #[test] fn test_core_circuit_invalid() { - let program_bytes = include_bytes!("core_package_invalid.leo"); + let program_bytes = include_str!("core_package_invalid.leo"); let program = parse_program(program_bytes).err().unwrap(); expect_symbol_table_error(program); @@ -28,7 +28,7 @@ fn test_core_circuit_invalid() { #[test] fn test_core_circuit_star_fail() { - let program_bytes = include_bytes!("core_circuit_star_fail.leo"); + let program_bytes = include_str!("core_circuit_star_fail.leo"); let error = parse_program(program_bytes).err().unwrap(); expect_symbol_table_error(error); @@ -36,7 +36,7 @@ fn test_core_circuit_star_fail() { #[test] fn test_core_package_invalid() { - let program_bytes = include_bytes!("core_package_invalid.leo"); + let program_bytes = include_str!("core_package_invalid.leo"); let error = parse_program(program_bytes).err().unwrap(); expect_symbol_table_error(error); @@ -44,7 +44,7 @@ fn test_core_package_invalid() { #[test] fn test_core_unstable_package_invalid() { - let program_bytes = include_bytes!("core_unstable_package_invalid.leo"); + let program_bytes = include_str!("core_unstable_package_invalid.leo"); let error = parse_program(program_bytes).err().unwrap(); expect_symbol_table_error(error); @@ -52,7 +52,7 @@ fn test_core_unstable_package_invalid() { #[test] fn test_unstable_blake2s_sanity() { - let program_bytes = include_bytes!("unstable_blake2s.leo"); + let program_bytes = include_str!("unstable_blake2s.leo"); let program = parse_program(program_bytes).unwrap(); assert_satisfied(program); diff --git a/compiler/tests/core/packages/unstable/blake2s/mod.rs b/compiler/tests/core/packages/unstable/blake2s/mod.rs index 2a94859fdd..0f59efcd20 100644 --- a/compiler/tests/core/packages/unstable/blake2s/mod.rs +++ b/compiler/tests/core/packages/unstable/blake2s/mod.rs @@ -32,7 +32,7 @@ use snarkos_models::algorithms::PRF; #[test] fn test_arguments_length_fail() { - let program_bytes = include_bytes!("arguments_length_fail.leo"); + let program_bytes = include_str!("arguments_length_fail.leo"); let error = parse_program(program_bytes).err().unwrap(); expect_type_inference_error(error); @@ -40,7 +40,7 @@ fn test_arguments_length_fail() { #[test] fn test_arguments_type_fail() { - let program_bytes = include_bytes!("arguments_type_fail.leo"); + let program_bytes = include_str!("arguments_type_fail.leo"); let error = parse_program(program_bytes).err().unwrap(); expect_type_inference_error(error); @@ -80,7 +80,7 @@ fn test_blake2s_random() { // The `blake2s_random.leo` program will compute a blake2s hash digest and compare it against // the expected value - let bytes = include_bytes!("blake2s_random.leo"); + let bytes = include_str!("blake2s_random.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ diff --git a/compiler/tests/definition/mod.rs b/compiler/tests/definition/mod.rs index 7b38d695fc..7cec04fcd5 100644 --- a/compiler/tests/definition/mod.rs +++ b/compiler/tests/definition/mod.rs @@ -18,7 +18,7 @@ use crate::{assert_satisfied, import::set_local_dir, parse_program}; #[test] fn test_out_of_order() { - let program_bytes = include_bytes!("out_of_order.leo"); + let program_bytes = include_str!("out_of_order.leo"); let program = parse_program(program_bytes).unwrap(); @@ -30,7 +30,7 @@ fn test_out_of_order() { fn test_out_of_order_with_import() { set_local_dir(); - let program_bytes = include_bytes!("out_of_order_with_import.leo"); + let program_bytes = include_str!("out_of_order_with_import.leo"); let program = parse_program(program_bytes).unwrap(); diff --git a/compiler/tests/field/mod.rs b/compiler/tests/field/mod.rs index 0cb5e4198c..a36dcd3539 100644 --- a/compiler/tests/field/mod.rs +++ b/compiler/tests/field/mod.rs @@ -52,7 +52,7 @@ fn test_negate() { let a_string = field_to_decimal_string(a); let b_string = field_to_decimal_string(b); - let bytes = include_bytes!("negate.leo"); + let bytes = include_str!("negate.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -81,7 +81,7 @@ fn test_add() { let b_string = field_to_decimal_string(b); let c_string = field_to_decimal_string(c); - let bytes = include_bytes!("add.leo"); + let bytes = include_str!("add.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -111,7 +111,7 @@ fn test_sub() { let b_string = field_to_decimal_string(b); let c_string = field_to_decimal_string(c); - let bytes = include_bytes!("sub.leo"); + let bytes = include_str!("sub.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -140,7 +140,7 @@ fn test_div() { let b_string = field_to_decimal_string(b); let c_string = field_to_decimal_string(c); - let bytes = include_bytes!("div.leo"); + let bytes = include_str!("div.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -169,7 +169,7 @@ fn test_mul() { let b_string = field_to_decimal_string(b); let c_string = field_to_decimal_string(c); - let bytes = include_bytes!("mul.leo"); + let bytes = include_str!("mul.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -197,7 +197,7 @@ fn test_eq() { // test equal - let bytes = include_bytes!("eq.leo"); + let bytes = include_str!("eq.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -237,7 +237,7 @@ fn test_console_assert_pass() { let a_string = field_to_decimal_string(a); - let bytes = include_bytes!("console_assert.leo"); + let bytes = include_str!("console_assert.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -266,7 +266,7 @@ fn test_console_assert_fail() { let a_string = field_to_decimal_string(a); let b_string = field_to_decimal_string(b); - let bytes = include_bytes!("console_assert.leo"); + let bytes = include_str!("console_assert.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -290,7 +290,7 @@ fn test_ternary() { let a_string = field_to_decimal_string(a); let b_string = field_to_decimal_string(b); - let bytes = include_bytes!("ternary.leo"); + let bytes = include_str!("ternary.leo"); let mut program = parse_program(bytes).unwrap(); // true -> field a @@ -322,14 +322,14 @@ fn test_ternary() { // // pub fn output_one(program: EdwardsTestCompiler) { -// let expected = include_bytes!("output_/register_one.out"); +// let expected = include_str!("output_/register_one.out"); // let actual = get_output(program); // // assert_eq!(expected, actual.bytes().as_slice()); // } // // pub fn output_zero(program: EdwardsTestCompiler) { -// let expected = include_bytes!("output_/register_zero.out"); +// let expected = include_str!("output_/register_zero.out"); // let actual = get_output(program); // // assert_eq!(expected, actual.bytes().as_slice()); @@ -337,9 +337,9 @@ fn test_ternary() { // // #[test] // fn test_registers() { -// let program_bytes = include_bytes!("output_register.leo"); -// let one_input_bytes = include_bytes!("input/register_one.in"); -// let zero_input_bytes = include_bytes!("input/register_zero.in"); +// let program_bytes = include_str!("output_register.leo"); +// let one_input_bytes = include_str!("input/register_one.in"); +// let zero_input_bytes = include_str!("input/register_zero.in"); // // // test 1field input register => 1field output register // let program = parse_program_with_input(program_bytes, one_input_bytes).unwrap(); diff --git a/compiler/tests/function/mod.rs b/compiler/tests/function/mod.rs index 8c8e7cb31a..8849e57f4f 100644 --- a/compiler/tests/function/mod.rs +++ b/compiler/tests/function/mod.rs @@ -26,7 +26,7 @@ use leo_compiler::errors::{CompilerError, ExpressionError, FunctionError, Statem #[test] fn test_empty() { - let bytes = include_bytes!("empty.leo"); + let bytes = include_str!("empty.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -34,7 +34,7 @@ fn test_empty() { #[test] fn test_iteration() { - let bytes = include_bytes!("iteration.leo"); + let bytes = include_str!("iteration.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -42,7 +42,7 @@ fn test_iteration() { #[test] fn test_iteration_repeated() { - let bytes = include_bytes!("iteration_repeated.leo"); + let bytes = include_str!("iteration_repeated.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -63,7 +63,7 @@ fn test_newlines() { #[test] fn test_multiple_returns() { - let bytes = include_bytes!("multiple.leo"); + let bytes = include_str!("multiple.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -85,7 +85,7 @@ fn test_multiple_returns_main() { #[test] fn test_repeated_function_call() { - let bytes = include_bytes!("repeated.leo"); + let bytes = include_str!("repeated.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -93,7 +93,7 @@ fn test_repeated_function_call() { #[test] fn test_return() { - let bytes = include_bytes!("return.leo"); + let bytes = include_str!("return.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -101,7 +101,7 @@ fn test_return() { #[test] fn test_scope_fail() { - let bytes = include_bytes!("scope_fail.leo"); + let bytes = include_str!("scope_fail.leo"); let program = parse_program(bytes).unwrap(); match expect_compiler_error(program) { @@ -117,7 +117,7 @@ fn test_scope_fail() { #[test] fn test_undefined() { - let bytes = include_bytes!("undefined.leo"); + let bytes = include_str!("undefined.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -125,7 +125,7 @@ fn test_undefined() { #[test] fn test_value_unchanged() { - let bytes = include_bytes!("value_unchanged.leo"); + let bytes = include_str!("value_unchanged.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -133,7 +133,7 @@ fn test_value_unchanged() { #[test] fn test_array_input() { - let bytes = include_bytes!("array_input.leo"); + let bytes = include_str!("array_input.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error) @@ -143,7 +143,7 @@ fn test_array_input() { #[test] fn test_return_array_nested_fail() { - let bytes = include_bytes!("return_array_nested_fail.leo"); + let bytes = include_str!("return_array_nested_fail.leo"); let program = parse_program(bytes).unwrap(); let _err = expect_compiler_error(program); @@ -151,7 +151,7 @@ fn test_return_array_nested_fail() { #[test] fn test_return_array_nested_pass() { - let bytes = include_bytes!("return_array_nested_pass.leo"); + let bytes = include_str!("return_array_nested_pass.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -159,7 +159,7 @@ fn test_return_array_nested_pass() { #[test] fn test_return_array_tuple_fail() { - let bytes = include_bytes!("return_array_tuple_fail.leo"); + let bytes = include_str!("return_array_tuple_fail.leo"); let program = parse_program(bytes).unwrap(); let _err = expect_compiler_error(program); @@ -167,7 +167,7 @@ fn test_return_array_tuple_fail() { #[test] fn test_return_array_tuple_pass() { - let bytes = include_bytes!("return_array_tuple_pass.leo"); + let bytes = include_str!("return_array_tuple_pass.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -177,7 +177,7 @@ fn test_return_array_tuple_pass() { #[test] fn test_return_tuple() { - let bytes = include_bytes!("return_tuple.leo"); + let bytes = include_str!("return_tuple.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -185,7 +185,7 @@ fn test_return_tuple() { #[test] fn test_return_tuple_conditional() { - let bytes = include_bytes!("return_tuple_conditional.leo"); + let bytes = include_str!("return_tuple_conditional.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); diff --git a/compiler/tests/group/mod.rs b/compiler/tests/group/mod.rs index c560afdc57..58548b93e3 100644 --- a/compiler/tests/group/mod.rs +++ b/compiler/tests/group/mod.rs @@ -15,8 +15,13 @@ // along with the Leo library. If not, see . use crate::{ - assert_satisfied, expect_compiler_error, expect_synthesis_error, field::field_to_decimal_string, - generate_main_input, parse_program, parse_program_with_input, + assert_satisfied, + expect_compiler_error, + expect_synthesis_error, + field::field_to_decimal_string, + generate_main_input, + parse_program, + parse_program_with_input, }; use leo_ast::{GroupCoordinate, GroupTuple, GroupValue, InputValue, Span}; @@ -47,7 +52,7 @@ pub fn group_element_to_input_value(g: EdwardsAffine) -> GroupValue { #[test] fn test_one() { - let bytes = include_bytes!("one.leo"); + let bytes = include_str!("one.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -55,7 +60,7 @@ fn test_one() { #[test] fn test_zero() { - let bytes = include_bytes!("zero.leo"); + let bytes = include_str!("zero.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -63,7 +68,7 @@ fn test_zero() { #[test] fn test_point() { - let bytes = include_bytes!("point.leo"); + let bytes = include_str!("point.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -71,7 +76,7 @@ fn test_point() { #[test] fn test_x_sign_high() { - let bytes = include_bytes!("x_sign_high.leo"); + let bytes = include_str!("x_sign_high.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -79,7 +84,7 @@ fn test_x_sign_high() { #[test] fn test_x_sign_low() { - let bytes = include_bytes!("x_sign_low.leo"); + let bytes = include_str!("x_sign_low.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -87,7 +92,7 @@ fn test_x_sign_low() { #[test] fn test_x_sign_inferred() { - let bytes = include_bytes!("x_sign_inferred.leo"); + let bytes = include_str!("x_sign_inferred.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -95,7 +100,7 @@ fn test_x_sign_inferred() { #[test] fn test_y_sign_high() { - let bytes = include_bytes!("y_sign_high.leo"); + let bytes = include_str!("y_sign_high.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -103,7 +108,7 @@ fn test_y_sign_high() { #[test] fn test_y_sign_low() { - let bytes = include_bytes!("y_sign_low.leo"); + let bytes = include_str!("y_sign_low.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -111,7 +116,7 @@ fn test_y_sign_low() { #[test] fn test_y_sign_inferred() { - let bytes = include_bytes!("y_sign_inferred.leo"); + let bytes = include_str!("y_sign_inferred.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -119,7 +124,7 @@ fn test_y_sign_inferred() { #[test] fn test_both_sign_high() { - let bytes = include_bytes!("both_sign_high.leo"); + let bytes = include_str!("both_sign_high.leo"); let program = parse_program(bytes).unwrap(); @@ -128,7 +133,7 @@ fn test_both_sign_high() { #[test] fn test_both_sign_low() { - let bytes = include_bytes!("both_sign_low.leo"); + let bytes = include_str!("both_sign_low.leo"); let program = parse_program(bytes).unwrap(); @@ -137,7 +142,7 @@ fn test_both_sign_low() { #[test] fn test_both_sign_inferred() { - let bytes = include_bytes!("both_sign_inferred.leo"); + let bytes = include_str!("both_sign_inferred.leo"); let program = parse_program(bytes).unwrap(); @@ -146,8 +151,8 @@ fn test_both_sign_inferred() { #[test] fn test_point_input() { - let program_bytes = include_bytes!("point_input.leo"); - let input_bytes = include_bytes!("input/point.in"); + let program_bytes = include_str!("point_input.leo"); + let input_bytes = include_str!("input/point.in"); let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); @@ -156,9 +161,9 @@ fn test_point_input() { #[test] fn test_input() { - let program_bytes = include_bytes!("input.leo"); - let input_bytes_pass = include_bytes!("input/valid.in"); - let input_bytes_fail = include_bytes!("input/invalid.in"); + let program_bytes = include_str!("input.leo"); + let input_bytes_pass = include_str!("input/valid.in"); + let input_bytes_fail = include_str!("input/invalid.in"); let program = parse_program_with_input(program_bytes, input_bytes_pass).unwrap(); @@ -182,7 +187,7 @@ fn test_negate() { let a_element = group_element_to_input_value(a); let b_element = group_element_to_input_value(b); - let bytes = include_bytes!("negate.leo"); + let bytes = include_str!("negate.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -210,7 +215,7 @@ fn test_add() { let b_element = group_element_to_input_value(b); let c_element = group_element_to_input_value(c); - let bytes = include_bytes!("add.leo"); + let bytes = include_str!("add.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -239,7 +244,7 @@ fn test_sub() { let b_element = group_element_to_input_value(b); let c_element = group_element_to_input_value(c); - let bytes = include_bytes!("sub.leo"); + let bytes = include_str!("sub.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -262,7 +267,7 @@ fn test_console_assert_pass() { let a_element = group_element_to_input_value(a); - let bytes = include_bytes!("assert_eq.leo"); + let bytes = include_str!("assert_eq.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -291,7 +296,7 @@ fn test_console_assert_fail() { let a_element = group_element_to_input_value(a); let b_element = group_element_to_input_value(b); - let bytes = include_bytes!("assert_eq.leo"); + let bytes = include_str!("assert_eq.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -318,7 +323,7 @@ fn test_eq() { // test equal - let bytes = include_bytes!("eq.leo"); + let bytes = include_str!("eq.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -359,7 +364,7 @@ fn test_ternary() { let a_element = group_element_to_input_value(a); let b_element = group_element_to_input_value(b); - let bytes = include_bytes!("ternary.leo"); + let bytes = include_str!("ternary.leo"); let mut program = parse_program(bytes).unwrap(); // true -> field a diff --git a/compiler/tests/import/mod.rs b/compiler/tests/import/mod.rs index d4bd578c0b..54857438ea 100644 --- a/compiler/tests/import/mod.rs +++ b/compiler/tests/import/mod.rs @@ -34,7 +34,7 @@ pub fn set_local_dir() { fn test_basic() { set_local_dir(); - let bytes = include_bytes!("basic.leo"); + let bytes = include_str!("basic.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -45,7 +45,7 @@ fn test_basic() { fn test_multiple() { set_local_dir(); - let bytes = include_bytes!("multiple.leo"); + let bytes = include_str!("multiple.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -56,7 +56,7 @@ fn test_multiple() { fn test_star() { set_local_dir(); - let bytes = include_bytes!("star.leo"); + let bytes = include_str!("star.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -67,7 +67,7 @@ fn test_star() { fn test_star_fail() { set_local_dir(); - let bytes = include_bytes!("star_fail.leo"); + let bytes = include_str!("star_fail.leo"); assert!(parse_program(bytes).is_err()); } @@ -76,7 +76,7 @@ fn test_star_fail() { fn test_alias() { set_local_dir(); - let bytes = include_bytes!("alias.leo"); + let bytes = include_str!("alias.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -88,7 +88,7 @@ fn test_alias() { fn test_names_pass() { set_local_dir(); - let bytes = include_bytes!("names.leo"); + let bytes = include_str!("names.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -99,7 +99,7 @@ fn test_names_pass() { fn test_names_fail_1() { set_local_dir(); - let bytes = include_bytes!("names_dash_a.leo"); + let bytes = include_str!("names_dash_a.leo"); assert!(parse_program(bytes).is_err()); } @@ -108,7 +108,7 @@ fn test_names_fail_1() { fn test_names_fail_2() { set_local_dir(); - let bytes = include_bytes!("names_a_dash.leo"); + let bytes = include_str!("names_a_dash.leo"); assert!(parse_program(bytes).is_err()); } @@ -117,7 +117,7 @@ fn test_names_fail_2() { fn test_names_fail_3() { set_local_dir(); - let bytes = include_bytes!("names_underscore.leo"); + let bytes = include_str!("names_underscore.leo"); assert!(parse_program(bytes).is_err()); } @@ -126,7 +126,7 @@ fn test_names_fail_3() { fn test_names_fail_4() { set_local_dir(); - let bytes = include_bytes!("names_dollar.leo"); + let bytes = include_str!("names_dollar.leo"); assert!(parse_program(bytes).is_err()); } @@ -136,7 +136,7 @@ fn test_names_fail_4() { fn test_many_import() { set_local_dir(); - let bytes = include_bytes!("many_import.leo"); + let bytes = include_str!("many_import.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -147,7 +147,7 @@ fn test_many_import() { fn test_many_import_star() { set_local_dir(); - let bytes = include_bytes!("many_import_star.leo"); + let bytes = include_str!("many_import_star.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); diff --git a/compiler/tests/integers/int_macro.rs b/compiler/tests/integers/int_macro.rs index cdcd3e7f3d..271c98c239 100644 --- a/compiler/tests/integers/int_macro.rs +++ b/compiler/tests/integers/int_macro.rs @@ -28,7 +28,7 @@ macro_rules! test_int { None => continue, }; - let bytes = include_bytes!("negate.leo"); + let bytes = include_str!("negate.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -42,14 +42,14 @@ macro_rules! test_int { } fn test_negate_min_fail() { - let bytes = include_bytes!("negate_min.leo"); + let bytes = include_str!("negate_min.leo"); let program = parse_program(bytes).unwrap(); expect_computation_error(program); } fn test_negate_zero() { - let bytes = include_bytes!("negate_zero.leo"); + let bytes = include_str!("negate_zero.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -58,28 +58,28 @@ macro_rules! test_int { impl IntegerTester for $name { fn test_min() { - let bytes = include_bytes!("min.leo"); + let bytes = include_str!("min.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); } fn test_min_fail() { - let bytes = include_bytes!("min_fail.leo"); + let bytes = include_str!("min_fail.leo"); let program = parse_program(bytes).unwrap(); expect_parsing_error(program); } fn test_max() { - let bytes = include_bytes!("max.leo"); + let bytes = include_str!("max.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); } fn test_max_fail() { - let bytes = include_bytes!("max_fail.leo"); + let bytes = include_str!("max_fail.leo"); let program = parse_program(bytes).unwrap(); expect_parsing_error(program); @@ -95,7 +95,7 @@ macro_rules! test_int { None => continue, }; - let bytes = include_bytes!("add.leo"); + let bytes = include_str!("add.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -124,7 +124,7 @@ macro_rules! test_int { None => continue, }; - let bytes = include_bytes!("sub.leo"); + let bytes = include_str!("sub.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -149,7 +149,7 @@ macro_rules! test_int { None => continue, }; - let bytes = include_bytes!("mul.leo"); + let bytes = include_str!("mul.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -176,7 +176,7 @@ macro_rules! test_int { continue; } - let bytes = include_bytes!("div.leo"); + let bytes = include_str!("div.leo"); let mut program = parse_program(bytes).unwrap(); // expect an error when dividing by zero @@ -220,7 +220,7 @@ macro_rules! test_int { None => continue, }; - let bytes = include_bytes!("pow.leo"); + let bytes = include_str!("pow.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -242,7 +242,7 @@ macro_rules! test_int { // test equal - let bytes = include_bytes!("eq.leo"); + let bytes = include_str!("eq.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -280,7 +280,7 @@ macro_rules! test_int { // test a != a == false - let bytes = include_bytes!("ne.leo"); + let bytes = include_str!("ne.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -318,7 +318,7 @@ macro_rules! test_int { // test equal - let bytes = include_bytes!("ge.leo"); + let bytes = include_str!("ge.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -356,7 +356,7 @@ macro_rules! test_int { // test equal - let bytes = include_bytes!("gt.leo"); + let bytes = include_str!("gt.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -394,7 +394,7 @@ macro_rules! test_int { // test equal - let bytes = include_bytes!("le.leo"); + let bytes = include_str!("le.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -432,7 +432,7 @@ macro_rules! test_int { // test equal - let bytes = include_bytes!("lt.leo"); + let bytes = include_str!("lt.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -468,7 +468,7 @@ macro_rules! test_int { let a: $type_ = rand::random(); // test equal - let bytes = include_bytes!("console_assert.leo"); + let bytes = include_str!("console_assert.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -504,7 +504,7 @@ macro_rules! test_int { let a: $type_ = rand::random(); let b: $type_ = rand::random(); - let bytes = include_bytes!("ternary.leo"); + let bytes = include_str!("ternary.leo"); let mut program = parse_program(bytes).unwrap(); // true -> field 1 diff --git a/compiler/tests/integers/uint_macro.rs b/compiler/tests/integers/uint_macro.rs index c85b6a68c4..15616370ae 100644 --- a/compiler/tests/integers/uint_macro.rs +++ b/compiler/tests/integers/uint_macro.rs @@ -20,28 +20,28 @@ macro_rules! test_uint { impl IntegerTester for $name { fn test_min() { - let bytes = include_bytes!("min.leo"); + let bytes = include_str!("min.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); } fn test_min_fail() { - let bytes = include_bytes!("min_fail.leo"); + let bytes = include_str!("min_fail.leo"); let program = parse_program(bytes).unwrap(); expect_parsing_error(program); } fn test_max() { - let bytes = include_bytes!("max.leo"); + let bytes = include_str!("max.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); } fn test_max_fail() { - let bytes = include_bytes!("max_fail.leo"); + let bytes = include_str!("max_fail.leo"); let program = parse_program(bytes).unwrap(); expect_parsing_error(program); @@ -57,7 +57,7 @@ macro_rules! test_uint { None => continue, }; - let bytes = include_bytes!("add.leo"); + let bytes = include_str!("add.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -82,7 +82,7 @@ macro_rules! test_uint { None => continue, }; - let bytes = include_bytes!("sub.leo"); + let bytes = include_str!("sub.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -107,7 +107,7 @@ macro_rules! test_uint { None => continue, }; - let bytes = include_bytes!("mul.leo"); + let bytes = include_str!("mul.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -132,7 +132,7 @@ macro_rules! test_uint { None => continue, }; - let bytes = include_bytes!("div.leo"); + let bytes = include_str!("div.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -158,7 +158,7 @@ macro_rules! test_uint { None => continue, }; - let bytes = include_bytes!("pow.leo"); + let bytes = include_str!("pow.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -180,7 +180,7 @@ macro_rules! test_uint { // test equal - let bytes = include_bytes!("eq.leo"); + let bytes = include_str!("eq.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -218,7 +218,7 @@ macro_rules! test_uint { // test a != a == false - let bytes = include_bytes!("ne.leo"); + let bytes = include_str!("ne.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -256,7 +256,7 @@ macro_rules! test_uint { // test equal - let bytes = include_bytes!("ge.leo"); + let bytes = include_str!("ge.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -294,7 +294,7 @@ macro_rules! test_uint { // test equal - let bytes = include_bytes!("gt.leo"); + let bytes = include_str!("gt.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -332,7 +332,7 @@ macro_rules! test_uint { // test equal - let bytes = include_bytes!("le.leo"); + let bytes = include_str!("le.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -370,7 +370,7 @@ macro_rules! test_uint { // test equal - let bytes = include_bytes!("lt.leo"); + let bytes = include_str!("lt.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -406,7 +406,7 @@ macro_rules! test_uint { let a: $type_ = rand::random(); // test equal - let bytes = include_bytes!("console_assert.leo"); + let bytes = include_str!("console_assert.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -442,7 +442,7 @@ macro_rules! test_uint { let a: $type_ = rand::random(); let b: $type_ = rand::random(); - let bytes = include_bytes!("ternary.leo"); + let bytes = include_str!("ternary.leo"); let mut program = parse_program(bytes).unwrap(); // true -> field 1 diff --git a/compiler/tests/mod.rs b/compiler/tests/mod.rs index d2d66b8d8b..434a19ff16 100644 --- a/compiler/tests/mod.rs +++ b/compiler/tests/mod.rs @@ -64,11 +64,10 @@ fn new_compiler() -> EdwardsTestCompiler { EdwardsTestCompiler::new(program_name, path, output_dir) } -pub(crate) fn parse_program(bytes: &[u8]) -> Result { +pub(crate) fn parse_program(program_string: &str) -> Result { let mut compiler = new_compiler(); - let program_string = String::from_utf8_lossy(bytes); - compiler.parse_program_from_string(&program_string)?; + compiler.parse_program_from_string(program_string)?; Ok(compiler) } diff --git a/compiler/tests/mutability/mod.rs b/compiler/tests/mutability/mod.rs index 8442357044..9bcfa25225 100644 --- a/compiler/tests/mutability/mod.rs +++ b/compiler/tests/mutability/mod.rs @@ -19,7 +19,7 @@ use leo_ast::InputValue; #[test] fn test_let() { - let bytes = include_bytes!("let.leo"); + let bytes = include_str!("let.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -27,7 +27,7 @@ fn test_let() { #[test] fn test_let_mut() { - let bytes = include_bytes!("let_mut.leo"); + let bytes = include_str!("let_mut.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -35,7 +35,7 @@ fn test_let_mut() { #[test] fn test_const_fail() { - let bytes = include_bytes!("const.leo"); + let bytes = include_str!("const.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -43,7 +43,7 @@ fn test_const_fail() { #[test] fn test_const_mut_fail() { - let bytes = include_bytes!("const_mut.leo"); + let bytes = include_str!("const_mut.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -51,7 +51,7 @@ fn test_const_mut_fail() { #[test] fn test_array() { - let bytes = include_bytes!("array.leo"); + let bytes = include_str!("array.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -59,7 +59,7 @@ fn test_array() { #[test] fn test_array_mut() { - let bytes = include_bytes!("array_mut.leo"); + let bytes = include_str!("array_mut.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -67,7 +67,7 @@ fn test_array_mut() { #[test] fn test_circuit() { - let bytes = include_bytes!("circuit.leo"); + let bytes = include_str!("circuit.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -75,7 +75,7 @@ fn test_circuit() { #[test] fn test_circuit_mut() { - let bytes = include_bytes!("circuit_mut.leo"); + let bytes = include_str!("circuit_mut.leo"); let program = parse_program(bytes).unwrap(); expect_compiler_error(program); @@ -83,7 +83,7 @@ fn test_circuit_mut() { #[test] fn test_circuit_variable_mut() { - let bytes = include_bytes!("circuit_variable_mut.leo"); + let bytes = include_str!("circuit_variable_mut.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -91,7 +91,7 @@ fn test_circuit_variable_mut() { #[test] fn test_circuit_function_mut() { - let bytes = include_bytes!("circuit_function_mut.leo"); + let bytes = include_str!("circuit_function_mut.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -99,7 +99,7 @@ fn test_circuit_function_mut() { #[test] fn test_circuit_static_function_mut() { - let bytes = include_bytes!("circuit_static_function_mut.leo"); + let bytes = include_str!("circuit_static_function_mut.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); @@ -107,7 +107,7 @@ fn test_circuit_static_function_mut() { #[test] fn test_function_input() { - let bytes = include_bytes!("function_input.leo"); + let bytes = include_str!("function_input.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]); @@ -119,7 +119,7 @@ fn test_function_input() { #[test] fn test_function_input_mut() { - let bytes = include_bytes!("function_input_mut.leo"); + let bytes = include_str!("function_input_mut.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]); diff --git a/compiler/tests/statements/conditional/mod.rs b/compiler/tests/statements/conditional/mod.rs index 958032c411..f9bdc2c47b 100644 --- a/compiler/tests/statements/conditional/mod.rs +++ b/compiler/tests/statements/conditional/mod.rs @@ -28,7 +28,7 @@ use leo_ast::InputValue; #[test] fn test_assert() { - let bytes = include_bytes!("assert.leo"); + let bytes = include_str!("assert.leo"); let mut program_1_pass = parse_program(bytes).unwrap(); let mut program_0_pass = program_1_pass.clone(); let mut program_2_fail = program_1_pass.clone(); @@ -60,7 +60,7 @@ fn test_assert() { #[test] fn test_mutate() { - let bytes = include_bytes!("mutate.leo"); + let bytes = include_str!("mutate.leo"); let mut program_1_pass = parse_program(bytes).unwrap(); let mut program_0_pass = program_1_pass.clone(); @@ -83,7 +83,7 @@ fn test_mutate() { #[test] fn test_for_loop() { - let bytes = include_bytes!("for_loop.leo"); + let bytes = include_str!("for_loop.leo"); let mut program_true_6 = parse_program(bytes).unwrap(); let mut program_false_0 = program_true_6.clone(); @@ -106,7 +106,7 @@ fn test_for_loop() { #[test] fn test_chain() { - let bytes = include_bytes!("chain.leo"); + let bytes = include_str!("chain.leo"); let mut program_1_1 = parse_program(bytes).unwrap(); let mut program_2_2 = program_1_1.clone(); let mut program_4_3 = program_1_1.clone(); @@ -147,7 +147,7 @@ fn test_chain() { #[test] fn test_nested() { - let bytes = include_bytes!("nested.leo"); + let bytes = include_str!("nested.leo"); let mut program_true_true_3 = parse_program(bytes).unwrap(); let mut program_true_false_1 = program_true_true_3.clone(); let mut program_false_false_0 = program_true_true_3.clone(); diff --git a/compiler/tests/statements/mod.rs b/compiler/tests/statements/mod.rs index 4680bee86d..68b4a38be6 100644 --- a/compiler/tests/statements/mod.rs +++ b/compiler/tests/statements/mod.rs @@ -23,7 +23,7 @@ pub mod conditional; #[test] fn test_ternary_basic() { - let bytes = include_bytes!("ternary_basic.leo"); + let bytes = include_str!("ternary_basic.leo"); let mut program = parse_program(bytes).unwrap(); let main_input = generate_main_input(vec![ @@ -51,7 +51,7 @@ fn test_ternary_basic() { #[test] fn test_iteration_basic() { - let bytes = include_bytes!("iteration_basic.leo"); + let bytes = include_str!("iteration_basic.leo"); let program = parse_program(bytes).unwrap(); assert_satisfied(program); @@ -59,7 +59,7 @@ fn test_iteration_basic() { #[test] fn test_num_returns_fail() { - let bytes = include_bytes!("num_returns_fail.leo"); + let bytes = include_str!("num_returns_fail.leo"); let error = parse_program(bytes).err().unwrap(); expect_type_inference_error(error); diff --git a/compiler/tests/syntax/identifiers/mod.rs b/compiler/tests/syntax/identifiers/mod.rs index c1d6fb7f86..f4dece3f59 100644 --- a/compiler/tests/syntax/identifiers/mod.rs +++ b/compiler/tests/syntax/identifiers/mod.rs @@ -18,7 +18,7 @@ use crate::parse_program; #[test] fn test_address_name_fail() { - let bytes = include_bytes!("address_fail.leo"); + let bytes = include_str!("address_fail.leo"); let syntax_error = parse_program(bytes).is_err(); assert!(syntax_error); @@ -26,7 +26,7 @@ fn test_address_name_fail() { #[test] fn test_console_name_fail() { - let bytes = include_bytes!("console_fail.leo"); + let bytes = include_str!("console_fail.leo"); let syntax_error = parse_program(bytes).is_err(); assert!(syntax_error); @@ -34,7 +34,7 @@ fn test_console_name_fail() { #[test] fn test_field_name_fail() { - let bytes = include_bytes!("field_fail.leo"); + let bytes = include_str!("field_fail.leo"); let syntax_error = parse_program(bytes).is_err(); assert!(syntax_error); @@ -42,7 +42,7 @@ fn test_field_name_fail() { #[test] fn test_group_name_fail() { - let bytes = include_bytes!("group_fail.leo"); + let bytes = include_str!("group_fail.leo"); let syntax_error = parse_program(bytes).is_err(); assert!(syntax_error); @@ -50,7 +50,7 @@ fn test_group_name_fail() { #[test] fn test_i8_name_fail() { - let bytes = include_bytes!("i8_fail.leo"); + let bytes = include_str!("i8_fail.leo"); let syntax_error = parse_program(bytes).is_err(); assert!(syntax_error); @@ -58,7 +58,7 @@ fn test_i8_name_fail() { #[test] fn test_input_name_fail() { - let bytes = include_bytes!("input_fail.leo"); + let bytes = include_str!("input_fail.leo"); let syntax_error = parse_program(bytes).is_err(); assert!(syntax_error); @@ -66,7 +66,7 @@ fn test_input_name_fail() { #[test] fn test_self_type_name_fail() { - let bytes = include_bytes!("self_type_fail.leo"); + let bytes = include_str!("self_type_fail.leo"); let syntax_error = parse_program(bytes).is_err(); assert!(syntax_error); @@ -74,7 +74,7 @@ fn test_self_type_name_fail() { #[test] fn test_self_keyword_name_fail() { - let bytes = include_bytes!("self_keyword_fail.leo"); + let bytes = include_str!("self_keyword_fail.leo"); let syntax_error = parse_program(bytes).is_err(); assert!(syntax_error); @@ -82,7 +82,7 @@ fn test_self_keyword_name_fail() { #[test] fn test_true_name_fail() { - let bytes = include_bytes!("true_fail.leo"); + let bytes = include_str!("true_fail.leo"); let syntax_error = parse_program(bytes).is_err(); assert!(syntax_error); @@ -90,7 +90,7 @@ fn test_true_name_fail() { #[test] fn test_u8_name_fail() { - let bytes = include_bytes!("u8_fail.leo"); + let bytes = include_str!("u8_fail.leo"); let syntax_error = parse_program(bytes).is_err(); assert!(syntax_error); diff --git a/compiler/tests/syntax/mod.rs b/compiler/tests/syntax/mod.rs index a4fd56f095..f8429a28c6 100644 --- a/compiler/tests/syntax/mod.rs +++ b/compiler/tests/syntax/mod.rs @@ -25,7 +25,7 @@ pub mod identifiers; #[test] #[ignore] fn test_semicolon() { - let bytes = include_bytes!("semicolon.leo"); + let bytes = include_str!("semicolon.leo"); let error = parse_program(bytes).err().unwrap(); match error { @@ -36,7 +36,7 @@ fn test_semicolon() { #[test] fn test_undefined() { - let bytes = include_bytes!("undefined.leo"); + let bytes = include_str!("undefined.leo"); let program = parse_program(bytes).unwrap(); let error = expect_compiler_error(program); @@ -76,7 +76,7 @@ fn input_syntax_error() { #[test] fn test_compare_mismatched_types() { - let bytes = include_bytes!("compare_mismatched_types.leo"); + let bytes = include_str!("compare_mismatched_types.leo"); let error = parse_program(bytes).err().unwrap(); // Expect a type inference error. diff --git a/compiler/tests/tuples/mod.rs b/compiler/tests/tuples/mod.rs index 9c52764c5f..4ec0ee3873 100644 --- a/compiler/tests/tuples/mod.rs +++ b/compiler/tests/tuples/mod.rs @@ -18,7 +18,7 @@ use crate::{assert_satisfied, parse_program}; #[test] fn test_tuple_basic() { - let program_bytes = include_bytes!("basic.leo"); + let program_bytes = include_str!("basic.leo"); let program = parse_program(program_bytes).unwrap(); @@ -27,7 +27,7 @@ fn test_tuple_basic() { #[test] fn test_tuple_access() { - let program_bytes = include_bytes!("access.leo"); + let program_bytes = include_str!("access.leo"); let program = parse_program(program_bytes).unwrap(); @@ -36,7 +36,7 @@ fn test_tuple_access() { #[test] fn test_tuple_typed() { - let program_bytes = include_bytes!("typed.leo"); + let program_bytes = include_str!("typed.leo"); let program = parse_program(program_bytes).unwrap(); @@ -45,7 +45,7 @@ fn test_tuple_typed() { #[test] fn test_multiple() { - let program_bytes = include_bytes!("multiple.leo"); + let program_bytes = include_str!("multiple.leo"); let program = parse_program(program_bytes).unwrap(); @@ -54,7 +54,7 @@ fn test_multiple() { #[test] fn test_multiple_typed() { - let program_bytes = include_bytes!("multiple_typed.leo"); + let program_bytes = include_str!("multiple_typed.leo"); let program = parse_program(program_bytes).unwrap(); @@ -63,7 +63,7 @@ fn test_multiple_typed() { #[test] fn test_function() { - let program_bytes = include_bytes!("function.leo"); + let program_bytes = include_str!("function.leo"); let program = parse_program(program_bytes).unwrap(); @@ -72,7 +72,7 @@ fn test_function() { #[test] fn test_function_typed() { - let program_bytes = include_bytes!("function_typed.leo"); + let program_bytes = include_str!("function_typed.leo"); let program = parse_program(program_bytes).unwrap(); @@ -81,7 +81,7 @@ fn test_function_typed() { #[test] fn test_function_multiple() { - let progam_bytes = include_bytes!("function_multiple.leo"); + let progam_bytes = include_str!("function_multiple.leo"); let program = parse_program(progam_bytes).unwrap(); @@ -90,7 +90,7 @@ fn test_function_multiple() { #[test] fn test_nested() { - let program_bytes = include_bytes!("nested.leo"); + let program_bytes = include_str!("nested.leo"); let program = parse_program(program_bytes).unwrap(); @@ -99,7 +99,7 @@ fn test_nested() { #[test] fn test_nested_access() { - let program_bytes = include_bytes!("nested_access.leo"); + let program_bytes = include_str!("nested_access.leo"); let program = parse_program(program_bytes).unwrap(); @@ -108,7 +108,7 @@ fn test_nested_access() { #[test] fn test_nested_typed() { - let program_bytes = include_bytes!("nested_typed.leo"); + let program_bytes = include_str!("nested_typed.leo"); let program = parse_program(program_bytes).unwrap(); @@ -117,6 +117,6 @@ fn test_nested_typed() { // #[test] // fn test_input() { -// let input_bytes = include_bytes!("inputs/input.in"); -// let program_bytes = include_bytes!("") +// let input_bytes = include_str!("inputs/input.in"); +// let program_bytes = include_str!("") // }