From e3bfcdaf84cdca5d317369751d29c6e740581f50 Mon Sep 17 00:00:00 2001 From: ljedrz Date: Tue, 24 Nov 2020 11:02:46 +0100 Subject: [PATCH 01/17] perf(arithmetic): reuse some vectors used in mul and pow Signed-off-by: ljedrz --- gadgets/src/signed_integer/arithmetic/mul.rs | 14 +++++++++++--- gadgets/src/signed_integer/arithmetic/pow.rs | 2 +- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/gadgets/src/signed_integer/arithmetic/mul.rs b/gadgets/src/signed_integer/arithmetic/mul.rs index 2d4a8c4d12..214b5d0982 100644 --- a/gadgets/src/signed_integer/arithmetic/mul.rs +++ b/gadgets/src/signed_integer/arithmetic/mul.rs @@ -37,6 +37,8 @@ use snarkos_models::{ }, }; +use std::iter; + macro_rules! mul_int_impl { ($($gadget: ident)*) => ($( /// Bitwise multiplication of two signed integer objects. @@ -77,14 +79,16 @@ macro_rules! mul_int_impl { let mut bits = vec![false_bit; size]; // Compute double and add algorithm + let mut to_add = Vec::new(); + let mut a_shifted = Vec::new(); for (i, b_bit) in b.iter().enumerate() { // double - let mut a_shifted = vec![false_bit; i]; - a_shifted.append(&mut a.clone()); + a_shifted.extend(iter::repeat(false_bit).take(i)); + a_shifted.extend(a.iter()); a_shifted.truncate(size); // conditionally add - let mut to_add = Vec::with_capacity(a_shifted.len()); + to_add.reserve(a_shifted.len()); for (j, a_bit) in a_shifted.iter().enumerate() { let selected_bit = Boolean::conditionally_select( &mut cs.ns(|| format!("select product bit {} {}", i, j)), @@ -101,7 +105,11 @@ macro_rules! mul_int_impl { &to_add )?; let _carry = bits.pop(); + to_add.clear(); + a_shifted.clear(); } + drop(to_add); + drop(a_shifted); // Compute the maximum value of the sum let max_bits = <$gadget as Int>::SIZE; diff --git a/gadgets/src/signed_integer/arithmetic/pow.rs b/gadgets/src/signed_integer/arithmetic/pow.rs index 25e4aa8d48..dc90b34bbe 100644 --- a/gadgets/src/signed_integer/arithmetic/pow.rs +++ b/gadgets/src/signed_integer/arithmetic/pow.rs @@ -71,7 +71,7 @@ macro_rules! pow_int_impl { result = Self::conditionally_select( &mut cs.ns(|| format!("mul_by_self_or_result_{}", i)), - &bit, + bit, &mul_by_self?, &result, )?; From b2246f1151e76c2d50b6f333ce55840bf4302238 Mon Sep 17 00:00:00 2001 From: collin Date: Fri, 4 Dec 2020 12:51:39 -0500 Subject: [PATCH 02/17] use include_str in program state tests --- .../tests/input_files/program_state/mod.rs | 30 +++++++++---------- compiler/tests/mod.rs | 15 +++++----- 2 files changed, 22 insertions(+), 23 deletions(-) diff --git a/compiler/tests/input_files/program_state/mod.rs b/compiler/tests/input_files/program_state/mod.rs index d3e46194b1..f065d09d4f 100644 --- a/compiler/tests/input_files/program_state/mod.rs +++ b/compiler/tests/input_files/program_state/mod.rs @@ -18,32 +18,32 @@ use crate::{assert_satisfied, parse_program_with_state, parse_state}; #[test] fn test_basic() { - let bytes = include_bytes!("input/basic.state"); + let state_string = include_str!("input/basic.state"); - parse_state(bytes).unwrap(); + parse_state(state_string).unwrap(); } #[test] fn test_token_withdraw() { - let bytes = include_bytes!("input/token_withdraw.state"); + let state_string = include_str!("input/token_withdraw.state"); - parse_state(bytes).unwrap(); + parse_state(state_string).unwrap(); } #[test] fn test_access_state() { - let program_bytes = include_bytes!("access_state.leo"); - let state_bytes = include_bytes!("input/token_withdraw.state"); + let program_string = include_str!("access_state.leo"); + let state_string = include_str!("input/token_withdraw.state"); - let program = parse_program_with_state(program_bytes, state_bytes).unwrap(); + let program = parse_program_with_state(program_string, state_string).unwrap(); assert_satisfied(program); } #[test] fn test_access_all() { - let program_bytes = include_bytes!("access_all.leo"); - let state_bytes = include_bytes!("input/token_withdraw.state"); + let program_bytes = include_str!("access_all.leo"); + let state_bytes = include_str!("input/token_withdraw.state"); let program = parse_program_with_state(program_bytes, state_bytes).unwrap(); @@ -52,27 +52,27 @@ fn test_access_all() { #[test] fn test_visibility_fail() { - let state_bytes = include_bytes!("input/visibility_fail.state"); + let state_string = include_str!("input/visibility_fail.state"); - let is_err = parse_state(state_bytes).is_err(); + let is_err = parse_state(state_string).is_err(); assert!(is_err); } #[test] fn test_section_undefined() { - let state_bytes = include_bytes!("input/section_undefined.state"); + let state_string = include_str!("input/section_undefined.state"); - let is_err = parse_state(state_bytes).is_err(); + let is_err = parse_state(state_string).is_err(); assert!(is_err); } #[test] fn test_section_invalid() { - let state_bytes = include_bytes!("input/section_invalid.state"); + let state_string = include_str!("input/section_invalid.state"); - let is_err = parse_state(state_bytes).is_err(); + let is_err = parse_state(state_string).is_err(); assert!(is_err); } diff --git a/compiler/tests/mod.rs b/compiler/tests/mod.rs index a18efa9428..da31698251 100644 --- a/compiler/tests/mod.rs +++ b/compiler/tests/mod.rs @@ -83,9 +83,8 @@ pub(crate) fn parse_input(bytes: &[u8]) -> Result Result { +pub(crate) fn parse_state(state_string: &str) -> Result { let mut compiler = new_compiler(); - let state_string = String::from_utf8_lossy(bytes); let path = PathBuf::new(); compiler.parse_input(EMPTY_FILE, &path, &state_string, &path)?; @@ -124,17 +123,17 @@ pub fn parse_program_with_input( } pub fn parse_program_with_state( - program_bytes: &[u8], - state_bytes: &[u8], + program_string: &str, + state_string: &str, ) -> Result { let mut compiler = new_compiler(); - let program_string = String::from_utf8_lossy(program_bytes); - let state_string = String::from_utf8_lossy(state_bytes); + // let program_string = String::from_utf8_lossy(program_bytes); + // let state_string = String::from_utf8_lossy(state_bytes); let path = PathBuf::new(); - compiler.parse_input(EMPTY_FILE, &path, &state_string, &path)?; - compiler.parse_program_from_string(&program_string)?; + compiler.parse_input(EMPTY_FILE, &path, state_string, &path)?; + compiler.parse_program_from_string(program_string)?; Ok(compiler) } From 675937ba13287f859845a68b3ebadc7c98e9b8f3 Mon Sep 17 00:00:00 2001 From: collin Date: Fri, 4 Dec 2020 12:57:08 -0500 Subject: [PATCH 03/17] use include_str in program input tests --- .../program_input_and_program_state/mod.rs | 20 ++++++------- compiler/tests/mod.rs | 30 +++++++------------ compiler/tests/syntax/mod.rs | 5 ++-- 3 files changed, 22 insertions(+), 33 deletions(-) diff --git a/compiler/tests/input_files/program_input_and_program_state/mod.rs b/compiler/tests/input_files/program_input_and_program_state/mod.rs index c80bd98b7b..302f6fd433 100644 --- a/compiler/tests/input_files/program_input_and_program_state/mod.rs +++ b/compiler/tests/input_files/program_input_and_program_state/mod.rs @@ -18,27 +18,27 @@ use crate::{assert_satisfied, parse_input_and_state, parse_program_with_input_an #[test] fn test_basic() { - let input_bytes = include_bytes!("input/basic.in"); - let state_bytes = include_bytes!("input/basic.state"); + let input_string = include_str!("input/basic.in"); + let state_string = include_str!("input/basic.state"); - parse_input_and_state(input_bytes, state_bytes).unwrap(); + parse_input_and_state(input_string, state_string).unwrap(); } #[test] fn test_full() { - let input_bytes = include_bytes!("input/token_withdraw.in"); - let state_bytes = include_bytes!("input/token_withdraw.state"); + let input_string = include_str!("input/token_withdraw.in"); + let state_string = include_str!("input/token_withdraw.state"); - parse_input_and_state(input_bytes, state_bytes).unwrap(); + parse_input_and_state(input_string, state_string).unwrap(); } #[test] fn test_access() { - let program_bytes = include_bytes!("access.leo"); - let input_bytes = include_bytes!("input/token_withdraw.in"); - let state_bytes = include_bytes!("input/token_withdraw.state"); + let program_string = include_str!("access.leo"); + let input_string = include_str!("input/token_withdraw.in"); + let state_string = include_str!("input/token_withdraw.state"); - let program = parse_program_with_input_and_state(program_bytes, input_bytes, state_bytes).unwrap(); + let program = parse_program_with_input_and_state(program_strin, input_string, state_string).unwrap(); assert_satisfied(program); } diff --git a/compiler/tests/mod.rs b/compiler/tests/mod.rs index da31698251..2b7aa6bef0 100644 --- a/compiler/tests/mod.rs +++ b/compiler/tests/mod.rs @@ -73,12 +73,11 @@ pub(crate) fn parse_program(bytes: &[u8]) -> Result Result { +pub(crate) fn parse_input(input_string: &str) -> Result { let mut compiler = new_compiler(); - let input_string = String::from_utf8_lossy(bytes); let path = PathBuf::new(); - compiler.parse_input(&input_string, &path, EMPTY_FILE, &path)?; + compiler.parse_input(input_string, &path, EMPTY_FILE, &path)?; Ok(compiler) } @@ -87,21 +86,19 @@ pub(crate) fn parse_state(state_string: &str) -> Result Result { let mut compiler = new_compiler(); - let input_string = String::from_utf8_lossy(input_bytes); - let state_string = String::from_utf8_lossy(state_bytes); let path = PathBuf::new(); - compiler.parse_input(&input_string, &path, &state_string, &path)?; + compiler.parse_input(input_string, &path, state_string, &path)?; Ok(compiler) } @@ -127,9 +124,6 @@ pub fn parse_program_with_state( state_string: &str, ) -> Result { let mut compiler = new_compiler(); - - // let program_string = String::from_utf8_lossy(program_bytes); - // let state_string = String::from_utf8_lossy(state_bytes); let path = PathBuf::new(); compiler.parse_input(EMPTY_FILE, &path, state_string, &path)?; @@ -139,18 +133,14 @@ pub fn parse_program_with_state( } pub fn parse_program_with_input_and_state( - program_bytes: &[u8], - input_bytes: &[u8], - state_bytes: &[u8], + program_string: &str, + input_string: &str, + state_string: &str, ) -> Result { let mut compiler = new_compiler(); - - let program_string = String::from_utf8_lossy(program_bytes); - let input_string = String::from_utf8_lossy(input_bytes); - let state_string = String::from_utf8_lossy(state_bytes); let path = PathBuf::new(); - compiler.parse_input(&input_string, &path, &state_string, &path)?; + compiler.parse_input(input_string, &path, state_string, &path)?; compiler.parse_program_from_string(&program_string)?; Ok(compiler) diff --git a/compiler/tests/syntax/mod.rs b/compiler/tests/syntax/mod.rs index 55b7292d2a..a4fd56f095 100644 --- a/compiler/tests/syntax/mod.rs +++ b/compiler/tests/syntax/mod.rs @@ -63,10 +63,9 @@ fn test_undefined() { } #[test] -#[ignore] fn input_syntax_error() { - let bytes = include_bytes!("input_semicolon.leo"); - let error = parse_input(bytes).err().unwrap(); + let input_string = include_str!("input_semicolon.leo"); + let error = parse_input(input_string).err().unwrap(); // Expect an input parser error. match error { From 7976c739e9b92fb792876ae6c132d561c16f691c Mon Sep 17 00:00:00 2001 From: collin Date: Fri, 4 Dec 2020 15:20:59 -0500 Subject: [PATCH 04/17] use include_str in program input + state tests --- compiler/tests/array/mod.rs | 172 +++++++++--------- compiler/tests/boolean/mod.rs | 22 +-- .../core/packages/unstable/blake2s/mod.rs | 13 +- compiler/tests/function/mod.rs | 26 ++- .../tests/input_files/program_input/mod.rs | 22 +-- .../program_input_and_program_state/mod.rs | 2 +- compiler/tests/mod.rs | 11 +- compiler/tests/statements/conditional/mod.rs | 10 +- 8 files changed, 136 insertions(+), 142 deletions(-) diff --git a/compiler/tests/array/mod.rs b/compiler/tests/array/mod.rs index 59610476e5..c26c21edc6 100644 --- a/compiler/tests/array/mod.rs +++ b/compiler/tests/array/mod.rs @@ -41,17 +41,17 @@ pub fn output_zeros(program: EdwardsTestCompiler) { #[test] fn test_registers() { - let program_bytes = include_bytes!("registers.leo"); - let ones_input_bytes = include_bytes!("input/registers_ones.in"); - let zeros_input_bytes = include_bytes!("input/registers_zeros.in"); + let program_string = include_str!("registers.leo"); + let ones_input_string = include_str!("input/registers_ones.in"); + let zeros_input_string = include_str!("input/registers_zeros.in"); // test ones input register => ones output register - let program = parse_program_with_input(program_bytes, ones_input_bytes).unwrap(); + let program = parse_program_with_input(program_string, ones_input_string).unwrap(); output_ones(program); // test zeros input register => zeros output register - let program = parse_program_with_input(program_bytes, zeros_input_bytes).unwrap(); + let program = parse_program_with_input(program_string, zeros_input_string).unwrap(); output_zeros(program); } @@ -60,9 +60,9 @@ fn test_registers() { #[test] fn test_inline() { - let program_bytes = include_bytes!("inline.leo"); - let input_bytes = include_bytes!("input/three_ones.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("inline.leo"); + let input_string = include_str!("input/three_ones.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } @@ -77,72 +77,72 @@ fn test_inline_fail() { #[test] fn test_initializer() { - let program_bytes = include_bytes!("initializer.leo"); - let input_bytes = include_bytes!("input/three_ones.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("initializer.leo"); + let input_string = include_str!("input/three_ones.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_initializer_fail() { - let program_bytes = include_bytes!("initializer_fail.leo"); - let input_bytes = include_bytes!("input/three_ones.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("initializer_fail.leo"); + let input_string = include_str!("input/three_ones.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } #[test] fn test_initializer_input() { - let program_bytes = include_bytes!("initializer_input.leo"); - let input_bytes = include_bytes!("input/six_zeros.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("initializer_input.leo"); + let input_string = include_str!("input/six_zeros.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_initializer_input_fail() { - let program_bytes = include_bytes!("initializer_input.leo"); - let input_bytes = include_bytes!("input/initializer_fail.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("initializer_input.leo"); + let input_string = include_str!("input/initializer_fail.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } #[test] fn test_input_nested_3x2() { - let program_bytes = include_bytes!("input_nested_3x2.leo"); - let input_bytes = include_bytes!("input/input_nested_3x2.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("input_nested_3x2.leo"); + let input_string = include_str!("input/input_nested_3x2.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_input_nested_3x2_fail() { - let program_bytes = include_bytes!("input_nested_3x2_fail.leo"); - let input_bytes = include_bytes!("input/input_nested_3x2_fail.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("input_nested_3x2_fail.leo"); + let input_string = include_str!("input/input_nested_3x2_fail.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } #[test] fn test_input_tuple_3x2() { - let program_bytes = include_bytes!("input_tuple_3x2.leo"); - let input_bytes = include_bytes!("input/input_tuple_3x2.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("input_tuple_3x2.leo"); + let input_string = include_str!("input/input_tuple_3x2.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_input_tuple_3x2_fail() { - let program_bytes = include_bytes!("input_tuple_3x2_fail.leo"); - let input_bytes = include_bytes!("input/input_tuple_3x2_fail.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("input_tuple_3x2_fail.leo"); + let input_string = include_str!("input/input_tuple_3x2_fail.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } @@ -213,18 +213,18 @@ fn test_tuple_3x2_value_fail() { #[test] fn test_spread() { - let program_bytes = include_bytes!("spread.leo"); - let input_bytes = include_bytes!("input/three_ones.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("spread.leo"); + let input_string = include_str!("input/three_ones.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_slice() { - let program_bytes = include_bytes!("slice.leo"); - let input_bytes = include_bytes!("input/three_ones.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("slice.leo"); + let input_string = include_str!("input/three_ones.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } @@ -371,72 +371,72 @@ fn test_type_tuple_value_tuple_4x3x2_fail() { #[test] fn test_input_type_nested_value_nested_3x2() { - let program_bytes = include_bytes!("type_input_3x2.leo"); - let input_bytes = include_bytes!("input/type_nested_value_nested_3x2.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("type_input_3x2.leo"); + let input_string = include_str!("input/type_nested_value_nested_3x2.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_input_type_nested_value_nested_3x2_fail() { - let program_bytes = include_bytes!("type_input_3x2.leo"); - let input_bytes = include_bytes!("input/type_nested_value_nested_3x2_fail.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("type_input_3x2.leo"); + let input_string = include_str!("input/type_nested_value_nested_3x2_fail.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } #[test] fn test_input_type_nested_value_nested_4x3x2() { - let program_bytes = include_bytes!("type_input_4x3x2.leo"); - let input_bytes = include_bytes!("input/type_nested_value_nested_4x3x2.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("type_input_4x3x2.leo"); + let input_string = include_str!("input/type_nested_value_nested_4x3x2.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_input_type_nested_value_nested_4x3x2_fail() { - let program_bytes = include_bytes!("type_input_4x3x2.leo"); - let input_bytes = include_bytes!("input/type_nested_value_nested_4x3x2_fail.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("type_input_4x3x2.leo"); + let input_string = include_str!("input/type_nested_value_nested_4x3x2_fail.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } #[test] fn test_input_type_nested_value_tuple_3x2() { - let program_bytes = include_bytes!("type_input_3x2.leo"); - let input_bytes = include_bytes!("input/type_nested_value_tuple_3x2.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("type_input_3x2.leo"); + let input_string = include_str!("input/type_nested_value_tuple_3x2.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_input_type_nested_value_tuple_3x2_fail() { - let program_bytes = include_bytes!("type_input_3x2.leo"); - let input_bytes = include_bytes!("input/type_nested_value_tuple_3x2_fail.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("type_input_3x2.leo"); + let input_string = include_str!("input/type_nested_value_tuple_3x2_fail.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } #[test] fn test_input_type_nested_value_tuple_4x3x2() { - let program_bytes = include_bytes!("type_input_4x3x2.leo"); - let input_bytes = include_bytes!("input/type_nested_value_tuple_4x3x2.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("type_input_4x3x2.leo"); + let input_string = include_str!("input/type_nested_value_tuple_4x3x2.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program) } #[test] fn test_input_type_nested_value_tuple_4x3x2_fail() { - let program_bytes = include_bytes!("type_input_4x3x2.leo"); - let input_bytes = include_bytes!("input/type_nested_value_tuple_4x3x2_fail.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("type_input_4x3x2.leo"); + let input_string = include_str!("input/type_nested_value_tuple_4x3x2_fail.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } @@ -445,72 +445,72 @@ fn test_input_type_nested_value_tuple_4x3x2_fail() { #[test] fn test_input_type_tuple_value_nested_3x2() { - let program_bytes = include_bytes!("type_input_3x2.leo"); - let input_bytes = include_bytes!("input/type_tuple_value_nested_3x2.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("type_input_3x2.leo"); + let input_string = include_str!("input/type_tuple_value_nested_3x2.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_input_type_tuple_value_nested_3x2_fail() { - let program_bytes = include_bytes!("type_input_3x2.leo"); - let input_bytes = include_bytes!("input/type_tuple_value_nested_3x2_fail.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("type_input_3x2.leo"); + let input_string = include_str!("input/type_tuple_value_nested_3x2_fail.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } #[test] fn test_input_type_tuple_value_nested_4x3x2() { - let program_bytes = include_bytes!("type_input_4x3x2.leo"); - let input_bytes = include_bytes!("input/type_tuple_value_nested_4x3x2.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("type_input_4x3x2.leo"); + let input_string = include_str!("input/type_tuple_value_nested_4x3x2.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_input_type_tuple_value_nested_4x3x2_fail() { - let program_bytes = include_bytes!("type_input_4x3x2.leo"); - let input_bytes = include_bytes!("input/type_tuple_value_nested_4x3x2_fail.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("type_input_4x3x2.leo"); + let input_string = include_str!("input/type_tuple_value_nested_4x3x2_fail.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } #[test] fn test_input_type_tuple_value_tuple_3x2() { - let program_bytes = include_bytes!("type_input_3x2.leo"); - let input_bytes = include_bytes!("input/type_tuple_value_tuple_3x2.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("type_input_3x2.leo"); + let input_string = include_str!("input/type_tuple_value_tuple_3x2.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_input_type_tuple_value_tuple_3x2_fail() { - let program_bytes = include_bytes!("type_input_3x2.leo"); - let input_bytes = include_bytes!("input/type_tuple_value_tuple_3x2_fail.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("type_input_3x2.leo"); + let input_string = include_str!("input/type_tuple_value_tuple_3x2_fail.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } #[test] fn test_input_type_tuple_value_tuple_4x3x2() { - let program_bytes = include_bytes!("type_input_4x3x2.leo"); - let input_bytes = include_bytes!("input/type_tuple_value_tuple_4x3x2.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program_string = include_str!("type_input_4x3x2.leo"); + let input_string = include_str!("input/type_tuple_value_tuple_4x3x2.in"); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_input_type_tuple_value_tuple_4x3x2_fail() { - let program_bytes = include_bytes!("type_input_4x3x2.leo"); - let input_bytes = include_bytes!("input/type_tuple_value_tuple_4x3x2_fail.in"); - let syntax_error = parse_program_with_input(program_bytes, input_bytes).is_err(); + let program_string = include_str!("type_input_4x3x2.leo"); + let input_string = include_str!("input/type_tuple_value_tuple_4x3x2_fail.in"); + let syntax_error = parse_program_with_input(program_string, input_string).is_err(); assert!(syntax_error); } diff --git a/compiler/tests/boolean/mod.rs b/compiler/tests/boolean/mod.rs index 82eaeb8cf2..175ebce138 100644 --- a/compiler/tests/boolean/mod.rs +++ b/compiler/tests/boolean/mod.rs @@ -40,37 +40,37 @@ pub fn output_false(program: EdwardsTestCompiler) { #[test] fn test_input_pass() { - let program_bytes = include_bytes!("assert_eq_input.leo"); - let input_bytes = include_bytes!("input/true_true.in"); + let program_string = include_str!("assert_eq_input.leo"); + let input_string = include_str!("input/true_true.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } #[test] fn test_input_fail() { - let program_bytes = include_bytes!("assert_eq_input.leo"); - let input_bytes = include_bytes!("input/true_false.in"); + let program_string = include_str!("assert_eq_input.leo"); + let input_string = include_str!("input/true_false.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program = parse_program_with_input(program_string, input_string).unwrap(); expect_compiler_error(program); } #[test] fn test_registers() { - let program_bytes = include_bytes!("output_register.leo"); - let true_input_bytes = include_bytes!("input/registers_true.in"); - let false_input_bytes = include_bytes!("input/registers_false.in"); + let program_string = include_str!("output_register.leo"); + let true_input_string = include_str!("input/registers_true.in"); + let false_input_string = include_str!("input/registers_false.in"); // test true input register => true output register - let program = parse_program_with_input(program_bytes, true_input_bytes).unwrap(); + let program = parse_program_with_input(program_string, true_input_string).unwrap(); output_true(program); // test false input register => false output register - let program = parse_program_with_input(program_bytes, false_input_bytes).unwrap(); + let program = parse_program_with_input(program_string, false_input_string).unwrap(); output_false(program); } diff --git a/compiler/tests/core/packages/unstable/blake2s/mod.rs b/compiler/tests/core/packages/unstable/blake2s/mod.rs index 2b308db42e..2a94859fdd 100644 --- a/compiler/tests/core/packages/unstable/blake2s/mod.rs +++ b/compiler/tests/core/packages/unstable/blake2s/mod.rs @@ -48,17 +48,16 @@ fn test_arguments_type_fail() { #[test] fn test_blake2s_input() { - let input_bytes = include_bytes!("inputs/valid_input.in"); - let program_bytes = include_bytes!("blake2s_input.leo"); - let expected_bytes = include_bytes!("outputs/valid_output.out"); + let input_string = include_str!("inputs/valid_input.in"); + let program_string = include_str!("blake2s_input.leo"); + let expected_string = include_str!("outputs/valid_output.out"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program = parse_program_with_input(program_string, input_string).unwrap(); - let expected = std::str::from_utf8(expected_bytes).unwrap(); let actual_bytes = get_output(program); - let actual = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap(); + let actual_string = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap(); - assert_eq!(expected, actual) + assert_eq!(expected_string, actual_string) } #[test] diff --git a/compiler/tests/function/mod.rs b/compiler/tests/function/mod.rs index dc31094f76..8c8e7cb31a 100644 --- a/compiler/tests/function/mod.rs +++ b/compiler/tests/function/mod.rs @@ -50,16 +50,15 @@ fn test_iteration_repeated() { #[test] fn test_newlines() { - let input_bytes = include_bytes!("input/newlines.in"); - let program_bytes = include_bytes!("newlines.leo"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let input_string = include_str!("input/newlines.in"); + let program_string = include_str!("newlines.leo"); + let program = parse_program_with_input(program_string, input_string).unwrap(); - let expected_bytes = include_bytes!("output/newlines.out"); - let expected = std::str::from_utf8(expected_bytes).unwrap(); + let expected_string = include_str!("output/newlines.out"); let actual_bytes = get_output(program); - let actual = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap(); + let actual_string = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap(); - assert_eq!(expected, actual); + assert_eq!(expected_string, actual_string); } #[test] @@ -72,17 +71,16 @@ fn test_multiple_returns() { #[test] fn test_multiple_returns_main() { - let program_bytes = include_bytes!("multiple_main.leo"); - let input_bytes = include_bytes!("input/registers.in"); + let program_string = include_str!("multiple_main.leo"); + let input_string = include_str!("input/registers.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program = parse_program_with_input(program_string, input_string).unwrap(); - let expected_bytes = include_bytes!("output/registers.out"); - let expected = std::str::from_utf8(expected_bytes).unwrap(); + let expected_string = include_str!("output/registers.out"); let actual_bytes = get_output(program); - let actual = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap(); + let actual_string = std::str::from_utf8(actual_bytes.bytes().as_slice()).unwrap(); - assert_eq!(expected, actual); + assert_eq!(expected_string, actual_string); } #[test] diff --git a/compiler/tests/input_files/program_input/mod.rs b/compiler/tests/input_files/program_input/mod.rs index 830e3b8651..cf77a8e3ed 100644 --- a/compiler/tests/input_files/program_input/mod.rs +++ b/compiler/tests/input_files/program_input/mod.rs @@ -26,8 +26,8 @@ fn expect_fail(program: EdwardsTestCompiler) { #[test] fn test_input_pass() { - let program_bytes = include_bytes!("main.leo"); - let input_bytes = include_bytes!("input/main.in"); + let program_bytes = include_str!("main.leo"); + let input_bytes = include_str!("input/main.in"); let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); @@ -36,30 +36,30 @@ fn test_input_pass() { #[test] fn test_input_fail_name() { - let program_bytes = include_bytes!("main.leo"); - let input_bytes = include_bytes!("input/main_fail_name.in"); + let program_string = include_str!("main.leo"); + let input_string = include_str!("input/main_fail_name.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program = parse_program_with_input(program_string, input_string).unwrap(); expect_fail(program); } #[test] fn test_input_fail_type() { - let program_bytes = include_bytes!("main.leo"); - let input_bytes = include_bytes!("input/main_fail_type.in"); + let program_string = include_str!("main.leo"); + let input_string = include_str!("input/main_fail_type.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program = parse_program_with_input(program_string, input_string).unwrap(); expect_fail(program); } #[test] fn test_input_multiple() { - let program_bytes = include_bytes!("main_multiple.leo"); - let input_bytes = include_bytes!("input/main_multiple.in"); + let program_string = include_str!("main_multiple.leo"); + let input_string = include_str!("input/main_multiple.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } diff --git a/compiler/tests/input_files/program_input_and_program_state/mod.rs b/compiler/tests/input_files/program_input_and_program_state/mod.rs index 302f6fd433..26f2fead35 100644 --- a/compiler/tests/input_files/program_input_and_program_state/mod.rs +++ b/compiler/tests/input_files/program_input_and_program_state/mod.rs @@ -38,7 +38,7 @@ fn test_access() { let input_string = include_str!("input/token_withdraw.in"); let state_string = include_str!("input/token_withdraw.state"); - let program = parse_program_with_input_and_state(program_strin, input_string, state_string).unwrap(); + let program = parse_program_with_input_and_state(program_string, input_string, state_string).unwrap(); assert_satisfied(program); } diff --git a/compiler/tests/mod.rs b/compiler/tests/mod.rs index 2b7aa6bef0..d2d66b8d8b 100644 --- a/compiler/tests/mod.rs +++ b/compiler/tests/mod.rs @@ -104,17 +104,14 @@ pub(crate) fn parse_input_and_state( } pub fn parse_program_with_input( - program_bytes: &[u8], - input_bytes: &[u8], + program_string: &str, + input_string: &str, ) -> Result { let mut compiler = new_compiler(); - - let program_string = String::from_utf8_lossy(program_bytes); - let input_string = String::from_utf8_lossy(input_bytes); let path = PathBuf::new(); - compiler.parse_input(&input_string, &path, EMPTY_FILE, &path)?; - compiler.parse_program_from_string(&program_string)?; + compiler.parse_input(input_string, &path, EMPTY_FILE, &path)?; + compiler.parse_program_from_string(program_string)?; Ok(compiler) } diff --git a/compiler/tests/statements/conditional/mod.rs b/compiler/tests/statements/conditional/mod.rs index 3c243c9804..958032c411 100644 --- a/compiler/tests/statements/conditional/mod.rs +++ b/compiler/tests/statements/conditional/mod.rs @@ -205,19 +205,19 @@ fn output_zero(program: EdwardsTestCompiler) { #[test] fn test_multiple_returns() { - let program_bytes = include_bytes!("multiple_returns.leo"); + let program_string = include_str!("multiple_returns.leo"); // Check that an input value of 1 writes 1 to the output registers - let registers_one_bytes = include_bytes!("input/registers_one.in"); - let program = parse_program_with_input(program_bytes, registers_one_bytes).unwrap(); + let registers_one_string = include_str!("input/registers_one.in"); + let program = parse_program_with_input(program_string, registers_one_string).unwrap(); output_one(program); // Check that an input value of 0 writes 0 to the output registers - let registers_zero_bytes = include_bytes!("input/registers_zero.in"); - let program = parse_program_with_input(program_bytes, registers_zero_bytes).unwrap(); + let registers_zero_string = include_str!("input/registers_zero.in"); + let program = parse_program_with_input(program_string, registers_zero_string).unwrap(); output_zero(program); } From 674caf590278253ef08370ca88b53f37ccf4b3a0 Mon Sep 17 00:00:00 2001 From: collin Date: Fri, 4 Dec 2020 15:34:51 -0500 Subject: [PATCH 05/17] use include_str in all program tests --- compiler/tests/address/mod.rs | 44 ++++---- compiler/tests/array/mod.rs | 104 +++++++++--------- compiler/tests/boolean/mod.rs | 26 ++--- compiler/tests/circuits/mod.rs | 56 +++++----- compiler/tests/console/mod.rs | 24 ++-- compiler/tests/core/mod.rs | 10 +- .../core/packages/unstable/blake2s/mod.rs | 6 +- compiler/tests/definition/mod.rs | 4 +- compiler/tests/field/mod.rs | 28 ++--- compiler/tests/function/mod.rs | 32 +++--- compiler/tests/group/mod.rs | 57 +++++----- compiler/tests/import/mod.rs | 24 ++-- compiler/tests/integers/int_macro.rs | 40 +++---- compiler/tests/integers/uint_macro.rs | 34 +++--- compiler/tests/mod.rs | 5 +- compiler/tests/mutability/mod.rs | 26 ++--- compiler/tests/statements/conditional/mod.rs | 10 +- compiler/tests/statements/mod.rs | 6 +- compiler/tests/syntax/identifiers/mod.rs | 20 ++-- compiler/tests/syntax/mod.rs | 6 +- compiler/tests/tuples/mod.rs | 26 ++--- 21 files changed, 296 insertions(+), 292 deletions(-) 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!("") // } From 2352ebaf2c3357de6f0f814c78ba00e838faeb14 Mon Sep 17 00:00:00 2001 From: collin Date: Fri, 4 Dec 2020 15:48:43 -0500 Subject: [PATCH 06/17] rename all bytes variables to string --- compiler/tests/boolean/mod.rs | 52 ++++---- compiler/tests/circuits/mod.rs | 112 +++++++++--------- compiler/tests/console/mod.rs | 52 ++++---- compiler/tests/core/mod.rs | 22 ++-- .../core/packages/unstable/blake2s/mod.rs | 8 +- compiler/tests/definition/mod.rs | 8 +- compiler/tests/field/mod.rs | 44 +++---- compiler/tests/function/mod.rs | 64 +++++----- compiler/tests/group/mod.rs | 94 +++++++-------- compiler/tests/import/mod.rs | 48 ++++---- .../tests/input_files/program_input/mod.rs | 6 +- .../tests/input_files/program_state/mod.rs | 6 +- compiler/tests/integers/int_macro.rs | 96 +++++++-------- compiler/tests/integers/uint_macro.rs | 84 ++++++------- compiler/tests/mutability/mod.rs | 52 ++++---- compiler/tests/statements/conditional/mod.rs | 20 ++-- compiler/tests/statements/mod.rs | 14 +-- compiler/tests/syntax/identifiers/mod.rs | 40 +++---- compiler/tests/syntax/mod.rs | 12 +- compiler/tests/tuples/mod.rs | 48 ++++---- 20 files changed, 441 insertions(+), 441 deletions(-) diff --git a/compiler/tests/boolean/mod.rs b/compiler/tests/boolean/mod.rs index d71ff3def0..02d5dad962 100644 --- a/compiler/tests/boolean/mod.rs +++ b/compiler/tests/boolean/mod.rs @@ -79,32 +79,32 @@ fn test_registers() { #[test] fn test_not_true() { - let bytes = include_str!("not_true.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("not_true.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_not_false() { - let bytes = include_str!("not_false.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("not_false.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_not_mutable() { - let bytes = include_str!("not_mutable.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("not_mutable.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_not_u32() { - let bytes = include_str!("not_u32.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("not_u32.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } @@ -113,32 +113,32 @@ fn test_not_u32() { #[test] fn test_true_or_true() { - let bytes = include_str!("true_or_true.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("true_or_true.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_true_or_false() { - let bytes = include_str!("true_or_false.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("true_or_false.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_false_or_false() { - let bytes = include_str!("false_or_false.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("false_or_false.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_true_or_u32() { - let bytes = include_str!("true_or_u32.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("true_or_u32.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } @@ -147,32 +147,32 @@ fn test_true_or_u32() { #[test] fn test_true_and_true() { - let bytes = include_str!("true_and_true.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("true_and_true.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_true_and_false() { - let bytes = include_str!("true_and_false.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("true_and_false.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_false_and_false() { - let bytes = include_str!("false_and_false.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("false_and_false.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_true_and_u32() { - let bytes = include_str!("true_and_u32.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("true_and_u32.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } @@ -181,8 +181,8 @@ fn test_true_and_u32() { #[test] fn test_all() { - let bytes = include_str!("all.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("all.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } diff --git a/compiler/tests/circuits/mod.rs b/compiler/tests/circuits/mod.rs index 4bfdcdac34..8cad1e7b49 100644 --- a/compiler/tests/circuits/mod.rs +++ b/compiler/tests/circuits/mod.rs @@ -20,24 +20,24 @@ use crate::{assert_satisfied, expect_compiler_error, expect_type_inference_error #[test] fn test_inline() { - let bytes = include_str!("inline.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("inline.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_inline_fail() { - let bytes = include_str!("inline_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("inline_fail.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_inline_undefined() { - let bytes = include_str!("inline_undefined.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("inline_undefined.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } @@ -46,88 +46,88 @@ fn test_inline_undefined() { #[test] fn test_member_variable() { - let bytes = include_str!("member_variable.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("member_variable.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_member_variable_fail() { - let bytes = include_str!("member_variable_fail.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("member_variable_fail.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_member_variable_and_function() { - let bytes = include_str!("member_variable_and_function.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("member_variable_and_function.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_member_function() { - let bytes = include_str!("member_function.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("member_function.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_member_function_fail() { - let bytes = include_str!("member_function_fail.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("member_function_fail.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_member_function_invalid() { - let bytes = include_str!("member_function_invalid.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("member_function_invalid.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_member_function_nested() { - let bytes = include_str!("member_function_nested.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("member_function_nested.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_member_static_function() { - let bytes = include_str!("member_static_function.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("member_static_function.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_member_static_function_nested() { - let bytes = include_str!("member_static_function_nested.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("member_static_function_nested.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_member_static_function_invalid() { - let bytes = include_str!("member_static_function_invalid.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("member_static_function_invalid.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error) } #[test] fn test_member_static_function_undefined() { - let bytes = include_str!("member_static_function_undefined.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("member_static_function_undefined.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error) } @@ -136,64 +136,64 @@ fn test_member_static_function_undefined() { #[test] fn test_mutate_function_fail() { - let bytes = include_str!("mut_function_fail.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("mut_function_fail.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_mutate_self_variable() { - let bytes = include_str!("mut_self_variable.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("mut_self_variable.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_mutate_self_variable_fail() { - let bytes = include_str!("mut_self_variable_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("mut_self_variable_fail.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_mutate_self_function_fail() { - let bytes = include_str!("mut_self_function_fail.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("mut_self_function_fail.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_mutate_self_static_function_fail() { - let bytes = include_str!("mut_self_static_function_fail.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("mut_self_static_function_fail.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_mutate_static_function_fail() { - let bytes = include_str!("mut_static_function_fail.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("mut_static_function_fail.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_mutate_variable() { - let bytes = include_str!("mut_variable.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("mut_variable.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_mutate_variable_fail() { - let bytes = include_str!("mut_variable_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("mut_variable_fail.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } @@ -202,32 +202,32 @@ fn test_mutate_variable_fail() { #[test] fn test_self_fail() { - let bytes = include_str!("self_fail.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("self_fail.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_self_member_pass() { - let bytes = include_str!("self_member.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("self_member.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_self_member_invalid() { - let bytes = include_str!("self_member_invalid.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("self_member_invalid.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_self_member_undefined() { - let bytes = include_str!("self_member_undefined.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("self_member_undefined.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } @@ -236,16 +236,16 @@ fn test_self_member_undefined() { #[test] fn test_pedersen_mock() { - let bytes = include_str!("pedersen_mock.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("pedersen_mock.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_define_circuit_inside_circuit_function() { - let bytes = include_str!("define_circuit_inside_circuit_function.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("define_circuit_inside_circuit_function.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } diff --git a/compiler/tests/console/mod.rs b/compiler/tests/console/mod.rs index 9bf1f820df..15b7c309a9 100644 --- a/compiler/tests/console/mod.rs +++ b/compiler/tests/console/mod.rs @@ -19,63 +19,63 @@ use leo_ast::InputValue; #[test] fn test_log() { - let bytes = include_str!("log.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("log.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_log_fail() { - let bytes = include_str!("log_fail.leo"); + let program_string = include_str!("log_fail.leo"); - assert!(parse_program(bytes).is_err()); + assert!(parse_program(program_string).is_err()); } #[test] fn test_log_parameter() { - let bytes = include_str!("log_parameter.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("log_parameter.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_log_parameter_many() { - let bytes = include_str!("log_parameter_many.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("log_parameter_many.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_log_parameter_fail_unknown() { - let bytes = include_str!("log_parameter_fail_unknown.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("log_parameter_fail_unknown.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_log_parameter_fail_empty() { - let bytes = include_str!("log_parameter_fail_empty.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("log_parameter_fail_empty.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_log_parameter_fail_none() { - let bytes = include_str!("log_parameter_fail_empty.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("log_parameter_fail_empty.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_log_input() { - let bytes = include_str!("log_input.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("log_input.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]); @@ -88,8 +88,8 @@ fn test_log_input() { #[test] fn test_debug() { - let bytes = include_str!("debug.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("debug.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -98,8 +98,8 @@ fn test_debug() { #[test] fn test_error() { - let bytes = include_str!("error.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("error.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -108,8 +108,8 @@ fn test_error() { #[test] fn test_assert() { - let bytes = include_str!("assert.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("assert.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]); @@ -117,7 +117,7 @@ fn test_assert() { 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::Boolean(false)))]); @@ -128,15 +128,15 @@ fn test_assert() { #[test] fn test_conditional_assert() { - let bytes = include_str!("conditional_assert.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("conditional_assert.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]); program.set_main_input(main_input); 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::Boolean(false)))]); diff --git a/compiler/tests/core/mod.rs b/compiler/tests/core/mod.rs index 293b84f536..11ad5f71df 100644 --- a/compiler/tests/core/mod.rs +++ b/compiler/tests/core/mod.rs @@ -20,40 +20,40 @@ use crate::{assert_satisfied, expect_symbol_table_error, parse_program}; #[test] fn test_core_circuit_invalid() { - let program_bytes = include_str!("core_package_invalid.leo"); - let program = parse_program(program_bytes).err().unwrap(); + let program_string = include_str!("core_package_invalid.leo"); + let error = parse_program(program_string).err().unwrap(); - expect_symbol_table_error(program); + expect_symbol_table_error(error); } #[test] fn test_core_circuit_star_fail() { - let program_bytes = include_str!("core_circuit_star_fail.leo"); - let error = parse_program(program_bytes).err().unwrap(); + let program_string = include_str!("core_circuit_star_fail.leo"); + let error = parse_program(program_string).err().unwrap(); expect_symbol_table_error(error); } #[test] fn test_core_package_invalid() { - let program_bytes = include_str!("core_package_invalid.leo"); - let error = parse_program(program_bytes).err().unwrap(); + let program_string = include_str!("core_package_invalid.leo"); + let error = parse_program(program_string).err().unwrap(); expect_symbol_table_error(error); } #[test] fn test_core_unstable_package_invalid() { - let program_bytes = include_str!("core_unstable_package_invalid.leo"); - let error = parse_program(program_bytes).err().unwrap(); + let program_string = include_str!("core_unstable_package_invalid.leo"); + let error = parse_program(program_string).err().unwrap(); expect_symbol_table_error(error); } #[test] fn test_unstable_blake2s_sanity() { - let program_bytes = include_str!("unstable_blake2s.leo"); - let program = parse_program(program_bytes).unwrap(); + let program_string = include_str!("unstable_blake2s.leo"); + let program = parse_program(program_string).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 0f59efcd20..7bef75b1c4 100644 --- a/compiler/tests/core/packages/unstable/blake2s/mod.rs +++ b/compiler/tests/core/packages/unstable/blake2s/mod.rs @@ -32,16 +32,16 @@ use snarkos_models::algorithms::PRF; #[test] fn test_arguments_length_fail() { - let program_bytes = include_str!("arguments_length_fail.leo"); - let error = parse_program(program_bytes).err().unwrap(); + let program_string = include_str!("arguments_length_fail.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_arguments_type_fail() { - let program_bytes = include_str!("arguments_type_fail.leo"); - let error = parse_program(program_bytes).err().unwrap(); + let program_string = include_str!("arguments_type_fail.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } diff --git a/compiler/tests/definition/mod.rs b/compiler/tests/definition/mod.rs index 7cec04fcd5..75dff4e557 100644 --- a/compiler/tests/definition/mod.rs +++ b/compiler/tests/definition/mod.rs @@ -18,9 +18,9 @@ use crate::{assert_satisfied, import::set_local_dir, parse_program}; #[test] fn test_out_of_order() { - let program_bytes = include_str!("out_of_order.leo"); + let program_string = include_str!("out_of_order.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -30,9 +30,9 @@ fn test_out_of_order() { fn test_out_of_order_with_import() { set_local_dir(); - let program_bytes = include_str!("out_of_order_with_import.leo"); + let program_string = include_str!("out_of_order_with_import.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } diff --git a/compiler/tests/field/mod.rs b/compiler/tests/field/mod.rs index a36dcd3539..fa57001223 100644 --- a/compiler/tests/field/mod.rs +++ b/compiler/tests/field/mod.rs @@ -52,8 +52,8 @@ fn test_negate() { let a_string = field_to_decimal_string(a); let b_string = field_to_decimal_string(b); - let bytes = include_str!("negate.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("negate.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Field(a_string))), @@ -81,8 +81,8 @@ fn test_add() { let b_string = field_to_decimal_string(b); let c_string = field_to_decimal_string(c); - let bytes = include_str!("add.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("add.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Field(a_string))), @@ -111,8 +111,8 @@ fn test_sub() { let b_string = field_to_decimal_string(b); let c_string = field_to_decimal_string(c); - let bytes = include_str!("sub.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("sub.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Field(a_string))), @@ -140,8 +140,8 @@ fn test_div() { let b_string = field_to_decimal_string(b); let c_string = field_to_decimal_string(c); - let bytes = include_str!("div.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("div.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Field(a_string))), @@ -169,8 +169,8 @@ fn test_mul() { let b_string = field_to_decimal_string(b); let c_string = field_to_decimal_string(c); - let bytes = include_str!("mul.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("mul.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Field(a_string))), @@ -197,8 +197,8 @@ fn test_eq() { // test equal - let bytes = include_str!("eq.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("eq.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Field(a_string.clone()))), @@ -214,7 +214,7 @@ fn test_eq() { let c = a.eq(&b); - 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::Field(a_string))), @@ -237,8 +237,8 @@ fn test_console_assert_pass() { let a_string = field_to_decimal_string(a); - let bytes = include_str!("console_assert.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("console_assert.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Field(a_string.clone()))), @@ -266,8 +266,8 @@ fn test_console_assert_fail() { let a_string = field_to_decimal_string(a); let b_string = field_to_decimal_string(b); - let bytes = include_str!("console_assert.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("console_assert.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Field(a_string))), @@ -290,8 +290,8 @@ fn test_ternary() { let a_string = field_to_decimal_string(a); let b_string = field_to_decimal_string(b); - let bytes = include_str!("ternary.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("ternary.leo"); + let mut program = parse_program(program_string).unwrap(); // true -> field a let main_input = generate_main_input(vec![ @@ -305,7 +305,7 @@ fn test_ternary() { assert_satisfied(program); - let mut program = parse_program(bytes).unwrap(); + let mut program = parse_program(program_string).unwrap(); // false -> field b let main_input = generate_main_input(vec![ @@ -325,14 +325,14 @@ fn test_ternary() { // let expected = include_str!("output_/register_one.out"); // let actual = get_output(program); // -// assert_eq!(expected, actual.bytes().as_slice()); +// assert_eq!(expected, actual.program_string().as_slice()); // } // // pub fn output_zero(program: EdwardsTestCompiler) { // let expected = include_str!("output_/register_zero.out"); // let actual = get_output(program); // -// assert_eq!(expected, actual.bytes().as_slice()); +// assert_eq!(expected, actual.program_string().as_slice()); // } // // #[test] diff --git a/compiler/tests/function/mod.rs b/compiler/tests/function/mod.rs index 8849e57f4f..ac7202ce06 100644 --- a/compiler/tests/function/mod.rs +++ b/compiler/tests/function/mod.rs @@ -26,24 +26,24 @@ use leo_compiler::errors::{CompilerError, ExpressionError, FunctionError, Statem #[test] fn test_empty() { - let bytes = include_str!("empty.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("empty.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_iteration() { - let bytes = include_str!("iteration.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("iteration.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_iteration_repeated() { - let bytes = include_str!("iteration_repeated.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("iteration_repeated.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -63,8 +63,8 @@ fn test_newlines() { #[test] fn test_multiple_returns() { - let bytes = include_str!("multiple.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("multiple.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -85,24 +85,24 @@ fn test_multiple_returns_main() { #[test] fn test_repeated_function_call() { - let bytes = include_str!("repeated.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("repeated.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_return() { - let bytes = include_str!("return.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("return.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_scope_fail() { - let bytes = include_str!("scope_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("scope_fail.leo"); + let program = parse_program(program_string).unwrap(); match expect_compiler_error(program) { CompilerError::FunctionError(FunctionError::StatementError(StatementError::ExpressionError( @@ -117,24 +117,24 @@ fn test_scope_fail() { #[test] fn test_undefined() { - let bytes = include_str!("undefined.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("undefined.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_value_unchanged() { - let bytes = include_str!("value_unchanged.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("value_unchanged.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_array_input() { - let bytes = include_str!("array_input.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("array_input.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error) } @@ -143,32 +143,32 @@ fn test_array_input() { #[test] fn test_return_array_nested_fail() { - let bytes = include_str!("return_array_nested_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("return_array_nested_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_return_array_nested_pass() { - let bytes = include_str!("return_array_nested_pass.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("return_array_nested_pass.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_return_array_tuple_fail() { - let bytes = include_str!("return_array_tuple_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("return_array_tuple_fail.leo"); + let program = parse_program(program_string).unwrap(); let _err = expect_compiler_error(program); } #[test] fn test_return_array_tuple_pass() { - let bytes = include_str!("return_array_tuple_pass.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("return_array_tuple_pass.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -177,16 +177,16 @@ fn test_return_array_tuple_pass() { #[test] fn test_return_tuple() { - let bytes = include_str!("return_tuple.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("return_tuple.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_return_tuple_conditional() { - let bytes = include_str!("return_tuple_conditional.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("return_tuple_conditional.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } diff --git a/compiler/tests/group/mod.rs b/compiler/tests/group/mod.rs index 58548b93e3..ca383a33e3 100644 --- a/compiler/tests/group/mod.rs +++ b/compiler/tests/group/mod.rs @@ -52,124 +52,124 @@ pub fn group_element_to_input_value(g: EdwardsAffine) -> GroupValue { #[test] fn test_one() { - let bytes = include_str!("one.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("one.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_zero() { - let bytes = include_str!("zero.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("zero.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_point() { - let bytes = include_str!("point.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("point.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_x_sign_high() { - let bytes = include_str!("x_sign_high.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("x_sign_high.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_x_sign_low() { - let bytes = include_str!("x_sign_low.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("x_sign_low.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_x_sign_inferred() { - let bytes = include_str!("x_sign_inferred.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("x_sign_inferred.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_y_sign_high() { - let bytes = include_str!("y_sign_high.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("y_sign_high.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_y_sign_low() { - let bytes = include_str!("y_sign_low.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("y_sign_low.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_y_sign_inferred() { - let bytes = include_str!("y_sign_inferred.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("y_sign_inferred.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_both_sign_high() { - let bytes = include_str!("both_sign_high.leo"); + let program_string = include_str!("both_sign_high.leo"); - let program = parse_program(bytes).unwrap(); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_both_sign_low() { - let bytes = include_str!("both_sign_low.leo"); + let program_string = include_str!("both_sign_low.leo"); - let program = parse_program(bytes).unwrap(); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_both_sign_inferred() { - let bytes = include_str!("both_sign_inferred.leo"); + let program_string = include_str!("both_sign_inferred.leo"); - let program = parse_program(bytes).unwrap(); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_point_input() { - let program_bytes = include_str!("point_input.leo"); + let program_string = include_str!("point_input.leo"); let input_bytes = include_str!("input/point.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program = parse_program_with_input(program_string, input_bytes).unwrap(); assert_satisfied(program); } #[test] fn test_input() { - 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_string = include_str!("input.leo"); + let input_string_pass = include_str!("input/valid.in"); + let input_string_fail = include_str!("input/invalid.in"); - let program = parse_program_with_input(program_bytes, input_bytes_pass).unwrap(); + let program = parse_program_with_input(program_string, input_string_pass).unwrap(); assert_satisfied(program); - let program = parse_program_with_input(program_bytes, input_bytes_fail).unwrap(); + let program = parse_program_with_input(program_string, input_string_fail).unwrap(); expect_compiler_error(program); } @@ -187,8 +187,8 @@ fn test_negate() { let a_element = group_element_to_input_value(a); let b_element = group_element_to_input_value(b); - let bytes = include_str!("negate.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("negate.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Group(a_element))), @@ -215,8 +215,8 @@ fn test_add() { let b_element = group_element_to_input_value(b); let c_element = group_element_to_input_value(c); - let bytes = include_str!("add.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("add.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Group(a_element))), @@ -244,8 +244,8 @@ fn test_sub() { let b_element = group_element_to_input_value(b); let c_element = group_element_to_input_value(c); - let bytes = include_str!("sub.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("sub.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Group(a_element))), @@ -267,8 +267,8 @@ fn test_console_assert_pass() { let a_element = group_element_to_input_value(a); - let bytes = include_str!("assert_eq.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("assert_eq.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Group(a_element.clone()))), @@ -296,8 +296,8 @@ 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_str!("assert_eq.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("assert_eq.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Group(a_element))), @@ -323,8 +323,8 @@ fn test_eq() { // test equal - let bytes = include_str!("eq.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("eq.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Group(a_element.clone()))), @@ -340,7 +340,7 @@ fn test_eq() { let c = a.eq(&b); - 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::Group(a_element))), @@ -364,8 +364,8 @@ fn test_ternary() { let a_element = group_element_to_input_value(a); let b_element = group_element_to_input_value(b); - let bytes = include_str!("ternary.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("ternary.leo"); + let mut program = parse_program(program_string).unwrap(); // true -> field a let main_input = generate_main_input(vec![ @@ -379,7 +379,7 @@ fn test_ternary() { assert_satisfied(program); - let mut program = parse_program(bytes).unwrap(); + let mut program = parse_program(program_string).unwrap(); // false -> field b let main_input = generate_main_input(vec![ diff --git a/compiler/tests/import/mod.rs b/compiler/tests/import/mod.rs index 54857438ea..2218046389 100644 --- a/compiler/tests/import/mod.rs +++ b/compiler/tests/import/mod.rs @@ -34,8 +34,8 @@ pub fn set_local_dir() { fn test_basic() { set_local_dir(); - let bytes = include_str!("basic.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("basic.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -45,8 +45,8 @@ fn test_basic() { fn test_multiple() { set_local_dir(); - let bytes = include_str!("multiple.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("multiple.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -56,8 +56,8 @@ fn test_multiple() { fn test_star() { set_local_dir(); - let bytes = include_str!("star.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("star.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -67,8 +67,8 @@ fn test_star() { fn test_star_fail() { set_local_dir(); - let bytes = include_str!("star_fail.leo"); - assert!(parse_program(bytes).is_err()); + let program_string = include_str!("star_fail.leo"); + assert!(parse_program(program_string).is_err()); } #[test] @@ -76,8 +76,8 @@ fn test_star_fail() { fn test_alias() { set_local_dir(); - let bytes = include_str!("alias.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("alias.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -88,8 +88,8 @@ fn test_alias() { fn test_names_pass() { set_local_dir(); - let bytes = include_str!("names.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("names.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -99,8 +99,8 @@ fn test_names_pass() { fn test_names_fail_1() { set_local_dir(); - let bytes = include_str!("names_dash_a.leo"); - assert!(parse_program(bytes).is_err()); + let program_string = include_str!("names_dash_a.leo"); + assert!(parse_program(program_string).is_err()); } #[test] @@ -108,8 +108,8 @@ fn test_names_fail_1() { fn test_names_fail_2() { set_local_dir(); - let bytes = include_str!("names_a_dash.leo"); - assert!(parse_program(bytes).is_err()); + let program_string = include_str!("names_a_dash.leo"); + assert!(parse_program(program_string).is_err()); } #[test] @@ -117,8 +117,8 @@ fn test_names_fail_2() { fn test_names_fail_3() { set_local_dir(); - let bytes = include_str!("names_underscore.leo"); - assert!(parse_program(bytes).is_err()); + let program_string = include_str!("names_underscore.leo"); + assert!(parse_program(program_string).is_err()); } #[test] @@ -126,8 +126,8 @@ fn test_names_fail_3() { fn test_names_fail_4() { set_local_dir(); - let bytes = include_str!("names_dollar.leo"); - assert!(parse_program(bytes).is_err()); + let program_string = include_str!("names_dollar.leo"); + assert!(parse_program(program_string).is_err()); } // more complex tests @@ -136,8 +136,8 @@ fn test_names_fail_4() { fn test_many_import() { set_local_dir(); - let bytes = include_str!("many_import.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("many_import.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -147,8 +147,8 @@ fn test_many_import() { fn test_many_import_star() { set_local_dir(); - let bytes = include_str!("many_import_star.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("many_import_star.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } diff --git a/compiler/tests/input_files/program_input/mod.rs b/compiler/tests/input_files/program_input/mod.rs index cf77a8e3ed..befe97057e 100644 --- a/compiler/tests/input_files/program_input/mod.rs +++ b/compiler/tests/input_files/program_input/mod.rs @@ -26,10 +26,10 @@ fn expect_fail(program: EdwardsTestCompiler) { #[test] fn test_input_pass() { - let program_bytes = include_str!("main.leo"); - let input_bytes = include_str!("input/main.in"); + let program_string = include_str!("main.leo"); + let input_string = include_str!("input/main.in"); - let program = parse_program_with_input(program_bytes, input_bytes).unwrap(); + let program = parse_program_with_input(program_string, input_string).unwrap(); assert_satisfied(program); } diff --git a/compiler/tests/input_files/program_state/mod.rs b/compiler/tests/input_files/program_state/mod.rs index f065d09d4f..ac775270b1 100644 --- a/compiler/tests/input_files/program_state/mod.rs +++ b/compiler/tests/input_files/program_state/mod.rs @@ -42,10 +42,10 @@ fn test_access_state() { #[test] fn test_access_all() { - let program_bytes = include_str!("access_all.leo"); - let state_bytes = include_str!("input/token_withdraw.state"); + let program_string = include_str!("access_all.leo"); + let state_string = include_str!("input/token_withdraw.state"); - let program = parse_program_with_state(program_bytes, state_bytes).unwrap(); + let program = parse_program_with_state(program_string, state_string).unwrap(); assert_satisfied(program); } diff --git a/compiler/tests/integers/int_macro.rs b/compiler/tests/integers/int_macro.rs index 271c98c239..9346ced2d8 100644 --- a/compiler/tests/integers/int_macro.rs +++ b/compiler/tests/integers/int_macro.rs @@ -28,8 +28,8 @@ macro_rules! test_int { None => continue, }; - let bytes = include_str!("negate.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("negate.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), ("b", Some(InputValue::Integer($integer_type, b.to_string()))), @@ -42,15 +42,15 @@ macro_rules! test_int { } fn test_negate_min_fail() { - let bytes = include_str!("negate_min.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("negate_min.leo"); + let program = parse_program(program_string).unwrap(); expect_computation_error(program); } fn test_negate_zero() { - let bytes = include_str!("negate_zero.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("negate_zero.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } @@ -58,29 +58,29 @@ macro_rules! test_int { impl IntegerTester for $name { fn test_min() { - let bytes = include_str!("min.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("min.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } fn test_min_fail() { - let bytes = include_str!("min_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("min_fail.leo"); + let program = parse_program(program_string).unwrap(); expect_parsing_error(program); } fn test_max() { - let bytes = include_str!("max.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("max.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } fn test_max_fail() { - let bytes = include_str!("max_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("max_fail.leo"); + let program = parse_program(program_string).unwrap(); expect_parsing_error(program); } @@ -95,8 +95,8 @@ macro_rules! test_int { None => continue, }; - let bytes = include_str!("add.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("add.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -124,8 +124,8 @@ macro_rules! test_int { None => continue, }; - let bytes = include_str!("sub.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("sub.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -149,8 +149,8 @@ macro_rules! test_int { None => continue, }; - let bytes = include_str!("mul.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("mul.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -176,8 +176,8 @@ macro_rules! test_int { continue; } - let bytes = include_str!("div.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("div.leo"); + let mut program = parse_program(program_string).unwrap(); // expect an error when dividing by zero if b == 0 { @@ -220,8 +220,8 @@ macro_rules! test_int { None => continue, }; - let bytes = include_str!("pow.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("pow.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -242,8 +242,8 @@ macro_rules! test_int { // test equal - let bytes = include_str!("eq.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("eq.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -259,7 +259,7 @@ macro_rules! test_int { let c = a.eq(&b); - 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::Integer($integer_type, a.to_string()))), @@ -280,8 +280,8 @@ macro_rules! test_int { // test a != a == false - let bytes = include_str!("ne.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("ne.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -297,7 +297,7 @@ macro_rules! test_int { let c = a.ne(&b); - 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::Integer($integer_type, a.to_string()))), @@ -318,8 +318,8 @@ macro_rules! test_int { // test equal - let bytes = include_str!("ge.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("ge.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -335,7 +335,7 @@ macro_rules! test_int { let c = a.ge(&b); - 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::Integer($integer_type, a.to_string()))), @@ -356,8 +356,8 @@ macro_rules! test_int { // test equal - let bytes = include_str!("gt.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("gt.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -373,7 +373,7 @@ macro_rules! test_int { let c = a.gt(&b); - 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::Integer($integer_type, a.to_string()))), @@ -394,8 +394,8 @@ macro_rules! test_int { // test equal - let bytes = include_str!("le.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("le.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -411,7 +411,7 @@ macro_rules! test_int { let c = a.le(&b); - 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::Integer($integer_type, a.to_string()))), @@ -432,8 +432,8 @@ macro_rules! test_int { // test equal - let bytes = include_str!("lt.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("lt.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -449,7 +449,7 @@ macro_rules! test_int { let c = a.lt(&b); - 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::Integer($integer_type, a.to_string()))), @@ -468,8 +468,8 @@ macro_rules! test_int { let a: $type_ = rand::random(); // test equal - let bytes = include_str!("console_assert.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("console_assert.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -487,7 +487,7 @@ macro_rules! test_int { continue; } - 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::Integer($integer_type, a.to_string()))), @@ -504,8 +504,8 @@ macro_rules! test_int { let a: $type_ = rand::random(); let b: $type_ = rand::random(); - let bytes = include_str!("ternary.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("ternary.leo"); + let mut program = parse_program(program_string).unwrap(); // true -> field 1 let main_input = generate_main_input(vec![ @@ -520,7 +520,7 @@ macro_rules! test_int { assert_satisfied(program); // false -> field 2 - 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))), diff --git a/compiler/tests/integers/uint_macro.rs b/compiler/tests/integers/uint_macro.rs index 15616370ae..e220a82be7 100644 --- a/compiler/tests/integers/uint_macro.rs +++ b/compiler/tests/integers/uint_macro.rs @@ -20,29 +20,29 @@ macro_rules! test_uint { impl IntegerTester for $name { fn test_min() { - let bytes = include_str!("min.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("min.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } fn test_min_fail() { - let bytes = include_str!("min_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("min_fail.leo"); + let program = parse_program(program_string).unwrap(); expect_parsing_error(program); } fn test_max() { - let bytes = include_str!("max.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("max.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } fn test_max_fail() { - let bytes = include_str!("max_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("max_fail.leo"); + let program = parse_program(program_string).unwrap(); expect_parsing_error(program); } @@ -57,8 +57,8 @@ macro_rules! test_uint { None => continue, }; - let bytes = include_str!("add.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("add.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -82,8 +82,8 @@ macro_rules! test_uint { None => continue, }; - let bytes = include_str!("sub.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("sub.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -107,8 +107,8 @@ macro_rules! test_uint { None => continue, }; - let bytes = include_str!("mul.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("mul.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -132,8 +132,8 @@ macro_rules! test_uint { None => continue, }; - let bytes = include_str!("div.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("div.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -158,8 +158,8 @@ macro_rules! test_uint { None => continue, }; - let bytes = include_str!("pow.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("pow.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -180,8 +180,8 @@ macro_rules! test_uint { // test equal - let bytes = include_str!("eq.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("eq.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -197,7 +197,7 @@ macro_rules! test_uint { let c = a.eq(&b); - 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::Integer($integer_type, a.to_string()))), @@ -218,8 +218,8 @@ macro_rules! test_uint { // test a != a == false - let bytes = include_str!("ne.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("ne.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -235,7 +235,7 @@ macro_rules! test_uint { let c = a.ne(&b); - 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::Integer($integer_type, a.to_string()))), @@ -256,8 +256,8 @@ macro_rules! test_uint { // test equal - let bytes = include_str!("ge.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("ge.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -273,7 +273,7 @@ macro_rules! test_uint { let c = a.ge(&b); - 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::Integer($integer_type, a.to_string()))), @@ -294,8 +294,8 @@ macro_rules! test_uint { // test equal - let bytes = include_str!("gt.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("gt.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -311,7 +311,7 @@ macro_rules! test_uint { let c = a.gt(&b); - 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::Integer($integer_type, a.to_string()))), @@ -332,8 +332,8 @@ macro_rules! test_uint { // test equal - let bytes = include_str!("le.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("le.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -349,7 +349,7 @@ macro_rules! test_uint { let c = a.le(&b); - 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::Integer($integer_type, a.to_string()))), @@ -370,8 +370,8 @@ macro_rules! test_uint { // test equal - let bytes = include_str!("lt.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("lt.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -387,7 +387,7 @@ macro_rules! test_uint { let c = a.lt(&b); - 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::Integer($integer_type, a.to_string()))), @@ -406,8 +406,8 @@ macro_rules! test_uint { let a: $type_ = rand::random(); // test equal - let bytes = include_str!("console_assert.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("console_assert.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Integer($integer_type, a.to_string()))), @@ -425,7 +425,7 @@ macro_rules! test_uint { continue; } - 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::Integer($integer_type, a.to_string()))), @@ -442,8 +442,8 @@ macro_rules! test_uint { let a: $type_ = rand::random(); let b: $type_ = rand::random(); - let bytes = include_str!("ternary.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("ternary.leo"); + let mut program = parse_program(program_string).unwrap(); // true -> field 1 let main_input = generate_main_input(vec![ @@ -458,7 +458,7 @@ macro_rules! test_uint { assert_satisfied(program); // false -> field 2 - 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))), diff --git a/compiler/tests/mutability/mod.rs b/compiler/tests/mutability/mod.rs index 9bcfa25225..8f07c5746f 100644 --- a/compiler/tests/mutability/mod.rs +++ b/compiler/tests/mutability/mod.rs @@ -19,96 +19,96 @@ use leo_ast::InputValue; #[test] fn test_let() { - let bytes = include_str!("let.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("let.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_let_mut() { - let bytes = include_str!("let_mut.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("let_mut.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_const_fail() { - let bytes = include_str!("const.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("const.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_const_mut_fail() { - let bytes = include_str!("const_mut.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("const_mut.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_array() { - let bytes = include_str!("array.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("array.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_array_mut() { - let bytes = include_str!("array_mut.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("array_mut.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_circuit() { - let bytes = include_str!("circuit.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("circuit.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_circuit_mut() { - let bytes = include_str!("circuit_mut.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("circuit_mut.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_circuit_variable_mut() { - let bytes = include_str!("circuit_variable_mut.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("circuit_variable_mut.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_circuit_function_mut() { - let bytes = include_str!("circuit_function_mut.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("circuit_function_mut.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_circuit_static_function_mut() { - let bytes = include_str!("circuit_static_function_mut.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("circuit_static_function_mut.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } #[test] fn test_function_input() { - let bytes = include_str!("function_input.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("function_input.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![("a", Some(InputValue::Boolean(true)))]); @@ -119,8 +119,8 @@ fn test_function_input() { #[test] fn test_function_input_mut() { - let bytes = include_str!("function_input_mut.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("function_input_mut.leo"); + let mut program = parse_program(program_string).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 f9bdc2c47b..84d03eb71b 100644 --- a/compiler/tests/statements/conditional/mod.rs +++ b/compiler/tests/statements/conditional/mod.rs @@ -28,8 +28,8 @@ use leo_ast::InputValue; #[test] fn test_assert() { - let bytes = include_str!("assert.leo"); - let mut program_1_pass = parse_program(bytes).unwrap(); + let program_string = include_str!("assert.leo"); + let mut program_1_pass = parse_program(program_string).unwrap(); let mut program_0_pass = program_1_pass.clone(); let mut program_2_fail = program_1_pass.clone(); @@ -60,8 +60,8 @@ fn test_assert() { #[test] fn test_mutate() { - let bytes = include_str!("mutate.leo"); - let mut program_1_pass = parse_program(bytes).unwrap(); + let program_string = include_str!("mutate.leo"); + let mut program_1_pass = parse_program(program_string).unwrap(); let mut program_0_pass = program_1_pass.clone(); // Check that an input value of 1 satisfies the constraint system @@ -83,8 +83,8 @@ fn test_mutate() { #[test] fn test_for_loop() { - let bytes = include_str!("for_loop.leo"); - let mut program_true_6 = parse_program(bytes).unwrap(); + let program_string = include_str!("for_loop.leo"); + let mut program_true_6 = parse_program(program_string).unwrap(); let mut program_false_0 = program_true_6.clone(); // Check that an input value of true satisfies the constraint system @@ -106,8 +106,8 @@ fn test_for_loop() { #[test] fn test_chain() { - let bytes = include_str!("chain.leo"); - let mut program_1_1 = parse_program(bytes).unwrap(); + let program_string = include_str!("chain.leo"); + let mut program_1_1 = parse_program(program_string).unwrap(); let mut program_2_2 = program_1_1.clone(); let mut program_4_3 = program_1_1.clone(); @@ -147,8 +147,8 @@ fn test_chain() { #[test] fn test_nested() { - let bytes = include_str!("nested.leo"); - let mut program_true_true_3 = parse_program(bytes).unwrap(); + let program_string = include_str!("nested.leo"); + let mut program_true_true_3 = parse_program(program_string).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 68b4a38be6..b06386769c 100644 --- a/compiler/tests/statements/mod.rs +++ b/compiler/tests/statements/mod.rs @@ -23,8 +23,8 @@ pub mod conditional; #[test] fn test_ternary_basic() { - let bytes = include_str!("ternary_basic.leo"); - let mut program = parse_program(bytes).unwrap(); + let program_string = include_str!("ternary_basic.leo"); + let mut program = parse_program(program_string).unwrap(); let main_input = generate_main_input(vec![ ("a", Some(InputValue::Boolean(true))), @@ -35,7 +35,7 @@ fn test_ternary_basic() { 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::Boolean(false))), @@ -51,16 +51,16 @@ fn test_ternary_basic() { #[test] fn test_iteration_basic() { - let bytes = include_str!("iteration_basic.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("iteration_basic.leo"); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_num_returns_fail() { - let bytes = include_str!("num_returns_fail.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("num_returns_fail.leo"); + let error = parse_program(program_string).err().unwrap(); expect_type_inference_error(error); } diff --git a/compiler/tests/syntax/identifiers/mod.rs b/compiler/tests/syntax/identifiers/mod.rs index f4dece3f59..1adf8697d9 100644 --- a/compiler/tests/syntax/identifiers/mod.rs +++ b/compiler/tests/syntax/identifiers/mod.rs @@ -18,80 +18,80 @@ use crate::parse_program; #[test] fn test_address_name_fail() { - let bytes = include_str!("address_fail.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("address_fail.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_console_name_fail() { - let bytes = include_str!("console_fail.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("console_fail.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_field_name_fail() { - let bytes = include_str!("field_fail.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("field_fail.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_group_name_fail() { - let bytes = include_str!("group_fail.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("group_fail.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_i8_name_fail() { - let bytes = include_str!("i8_fail.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("i8_fail.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_input_name_fail() { - let bytes = include_str!("input_fail.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("input_fail.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_self_type_name_fail() { - let bytes = include_str!("self_type_fail.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("self_type_fail.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_self_keyword_name_fail() { - let bytes = include_str!("self_keyword_fail.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("self_keyword_fail.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_true_name_fail() { - let bytes = include_str!("true_fail.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("true_fail.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } #[test] fn test_u8_name_fail() { - let bytes = include_str!("u8_fail.leo"); - let syntax_error = parse_program(bytes).is_err(); + let program_string = include_str!("u8_fail.leo"); + let syntax_error = parse_program(program_string).is_err(); assert!(syntax_error); } diff --git a/compiler/tests/syntax/mod.rs b/compiler/tests/syntax/mod.rs index f8429a28c6..195fad9834 100644 --- a/compiler/tests/syntax/mod.rs +++ b/compiler/tests/syntax/mod.rs @@ -25,8 +25,8 @@ pub mod identifiers; #[test] #[ignore] fn test_semicolon() { - let bytes = include_str!("semicolon.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("semicolon.leo"); + let error = parse_program(program_string).err().unwrap(); match error { CompilerError::ParserError(ParserError::SyntaxError(_)) => {} @@ -36,8 +36,8 @@ fn test_semicolon() { #[test] fn test_undefined() { - let bytes = include_str!("undefined.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("undefined.leo"); + let program = parse_program(program_string).unwrap(); let error = expect_compiler_error(program); @@ -76,8 +76,8 @@ fn input_syntax_error() { #[test] fn test_compare_mismatched_types() { - let bytes = include_str!("compare_mismatched_types.leo"); - let error = parse_program(bytes).err().unwrap(); + let program_string = include_str!("compare_mismatched_types.leo"); + let error = parse_program(program_string).err().unwrap(); // Expect a type inference error. match error { diff --git a/compiler/tests/tuples/mod.rs b/compiler/tests/tuples/mod.rs index 4ec0ee3873..5ed5cd357f 100644 --- a/compiler/tests/tuples/mod.rs +++ b/compiler/tests/tuples/mod.rs @@ -18,105 +18,105 @@ use crate::{assert_satisfied, parse_program}; #[test] fn test_tuple_basic() { - let program_bytes = include_str!("basic.leo"); + let program_string = include_str!("basic.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_tuple_access() { - let program_bytes = include_str!("access.leo"); + let program_string = include_str!("access.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_tuple_typed() { - let program_bytes = include_str!("typed.leo"); + let program_string = include_str!("typed.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_multiple() { - let program_bytes = include_str!("multiple.leo"); + let program_string = include_str!("multiple.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_multiple_typed() { - let program_bytes = include_str!("multiple_typed.leo"); + let program_string = include_str!("multiple_typed.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_function() { - let program_bytes = include_str!("function.leo"); + let program_string = include_str!("function.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_function_typed() { - let program_bytes = include_str!("function_typed.leo"); + let program_string = include_str!("function_typed.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_function_multiple() { - let progam_bytes = include_str!("function_multiple.leo"); + let progam_string = include_str!("function_multiple.leo"); - let program = parse_program(progam_bytes).unwrap(); + let program = parse_program(progam_string).unwrap(); assert_satisfied(program); } #[test] fn test_nested() { - let program_bytes = include_str!("nested.leo"); + let program_string = include_str!("nested.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_nested_access() { - let program_bytes = include_str!("nested_access.leo"); + let program_string = include_str!("nested_access.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } #[test] fn test_nested_typed() { - let program_bytes = include_str!("nested_typed.leo"); + let program_string = include_str!("nested_typed.leo"); - let program = parse_program(program_bytes).unwrap(); + let program = parse_program(program_string).unwrap(); assert_satisfied(program); } // #[test] // fn test_input() { -// let input_bytes = include_str!("inputs/input.in"); -// let program_bytes = include_str!("") +// let input_string = include_str!("inputs/input.in"); +// let program_string = include_str!("") // } From 3a66d989191978813f443db4426317e0749975a6 Mon Sep 17 00:00:00 2001 From: collin Date: Fri, 4 Dec 2020 16:40:17 -0500 Subject: [PATCH 07/17] use include_str in symbol-table and type-inference modules --- symbol-table/tests/mod.rs | 7 ++----- symbol-table/tests/symbol_table/mod.rs | 16 ++++++++-------- type-inference/tests/arrays/mod.rs | 12 ++++++------ type-inference/tests/circuits/mod.rs | 4 ++-- type-inference/tests/functions/mod.rs | 4 ++-- type-inference/tests/mod.rs | 11 ++++------- type-inference/tests/tuples/mod.rs | 4 ++-- type-inference/tests/variables/mod.rs | 16 ++++++++-------- 8 files changed, 34 insertions(+), 40 deletions(-) diff --git a/symbol-table/tests/mod.rs b/symbol-table/tests/mod.rs index fb8a5ee290..21c7710cb6 100644 --- a/symbol-table/tests/mod.rs +++ b/symbol-table/tests/mod.rs @@ -34,15 +34,12 @@ impl TestSymbolTable { /// /// Returns a Leo syntax tree given a Leo program. /// - pub fn new(bytes: &[u8]) -> Self { - // Get file string from bytes. - let file_string = String::from_utf8_lossy(bytes); - + pub fn new(program_string: &str) -> Self { // Get test file path. let file_path = PathBuf::from(TEST_PROGRAM_PATH); // Get parser syntax tree. - let grammar = Grammar::new(&file_path, &*file_string).unwrap(); + let grammar = Grammar::new(&file_path, program_string).unwrap(); // Get Leo syntax tree. let ast = Ast::new(TEST_PROGRAM_PATH, &grammar); diff --git a/symbol-table/tests/symbol_table/mod.rs b/symbol-table/tests/symbol_table/mod.rs index 4d40891377..e5b820d4a4 100644 --- a/symbol-table/tests/symbol_table/mod.rs +++ b/symbol-table/tests/symbol_table/mod.rs @@ -25,8 +25,8 @@ use crate::TestSymbolTable; /// #[test] fn test_duplicate_circuit() { - let program_bytes = include_bytes!("duplicate_circuit.leo"); - let resolver = TestSymbolTable::new(program_bytes); + let program_string = include_str!("duplicate_circuit.leo"); + let resolver = TestSymbolTable::new(program_string); resolver.expect_pass_one_error(); } @@ -40,8 +40,8 @@ fn test_duplicate_circuit() { /// #[test] fn test_duplicate_function() { - let program_bytes = include_bytes!("duplicate_function.leo"); - let resolver = TestSymbolTable::new(program_bytes); + let program_string = include_str!("duplicate_function.leo"); + let resolver = TestSymbolTable::new(program_string); resolver.expect_pass_one_error(); } @@ -54,8 +54,8 @@ fn test_duplicate_function() { /// #[test] fn test_self_not_available() { - let program_bytes = include_bytes!("self_not_available.leo"); - let resolver = TestSymbolTable::new(program_bytes); + let program_string = include_str!("self_not_available.leo"); + let resolver = TestSymbolTable::new(program_string); resolver.expect_pass_two_error(); } @@ -68,8 +68,8 @@ fn test_self_not_available() { /// #[test] fn test_undefined_circuit() { - let program_bytes = include_bytes!("undefined_circuit.leo"); - let resolver = TestSymbolTable::new(program_bytes); + let program_string = include_str!("undefined_circuit.leo"); + let resolver = TestSymbolTable::new(program_string); resolver.expect_pass_two_error(); } diff --git a/type-inference/tests/arrays/mod.rs b/type-inference/tests/arrays/mod.rs index 72ab79478e..6877b90b76 100644 --- a/type-inference/tests/arrays/mod.rs +++ b/type-inference/tests/arrays/mod.rs @@ -18,27 +18,27 @@ use crate::TestTypeInference; #[test] fn test_empty_array() { - let bytes = include_bytes!("empty_array.leo"); + let program_string = include_str!("empty_array.leo"); - let check = TestTypeInference::new(bytes); + let check = TestTypeInference::new(program_string); check.expect_error(); } #[test] fn test_invalid_array_access() { - let bytes = include_bytes!("invalid_array_access.leo"); + let program_string = include_str!("invalid_array_access.leo"); - let check = TestTypeInference::new(bytes); + let check = TestTypeInference::new(program_string); check.expect_error(); } #[test] fn test_invalid_spread() { - let bytes = include_bytes!("invalid_spread.leo"); + let program_string = include_str!("invalid_spread.leo"); - let check = TestTypeInference::new(bytes); + let check = TestTypeInference::new(program_string); check.expect_error(); } diff --git a/type-inference/tests/circuits/mod.rs b/type-inference/tests/circuits/mod.rs index 8b8d585bd6..e05837c4d0 100644 --- a/type-inference/tests/circuits/mod.rs +++ b/type-inference/tests/circuits/mod.rs @@ -18,8 +18,8 @@ use crate::TestTypeInference; #[test] fn test_invalid_circuit() { - let bytes = include_bytes!("invalid_circuit.leo"); - let check = TestTypeInference::new(bytes); + let program_string = include_str!("invalid_circuit.leo"); + let check = TestTypeInference::new(program_string); check.expect_error(); } diff --git a/type-inference/tests/functions/mod.rs b/type-inference/tests/functions/mod.rs index 20e873cbaf..c353cad388 100644 --- a/type-inference/tests/functions/mod.rs +++ b/type-inference/tests/functions/mod.rs @@ -18,8 +18,8 @@ use crate::TestTypeInference; #[test] fn test_invalid_function() { - let bytes = include_bytes!("invalid_function.leo"); - let check = TestTypeInference::new(bytes); + let program_string = include_str!("invalid_function.leo"); + let check = TestTypeInference::new(program_string); check.expect_error(); } diff --git a/type-inference/tests/mod.rs b/type-inference/tests/mod.rs index e72bb9f005..40924eabfe 100644 --- a/type-inference/tests/mod.rs +++ b/type-inference/tests/mod.rs @@ -38,15 +38,12 @@ pub struct TestTypeInference { } impl TestTypeInference { - pub fn new(bytes: &[u8]) -> Self { - // Get file string from bytes. - let file_string = String::from_utf8_lossy(bytes); - + pub fn new(program_string: &str) -> Self { // Get test file path. let file_path = PathBuf::from(TEST_PROGRAM_PATH); // Get parser syntax tree. - let ast = Grammar::new(&file_path, &*file_string).unwrap(); + let ast = Grammar::new(&file_path, program_string).unwrap(); // Get typed syntax tree. let typed = Ast::new(TEST_PROGRAM_NAME, &ast); @@ -76,9 +73,9 @@ impl TestTypeInference { #[test] fn test_new() { - let bytes = include_bytes!("empty.leo"); + let program_string = include_str!("empty.leo"); - let type_inference = TestTypeInference::new(bytes); + let type_inference = TestTypeInference::new(program_string); type_inference.check() } diff --git a/type-inference/tests/tuples/mod.rs b/type-inference/tests/tuples/mod.rs index cc0549cffe..9667e11971 100644 --- a/type-inference/tests/tuples/mod.rs +++ b/type-inference/tests/tuples/mod.rs @@ -18,8 +18,8 @@ use crate::TestTypeInference; #[test] fn test_invalid_tuple_access() { - let bytes = include_bytes!("invalid_tuple_access.leo"); - let check = TestTypeInference::new(bytes); + let program_string = include_str!("invalid_tuple_access.leo"); + let check = TestTypeInference::new(program_string); check.expect_error(); } diff --git a/type-inference/tests/variables/mod.rs b/type-inference/tests/variables/mod.rs index 9e7b3dd1ea..1cadaa5e68 100644 --- a/type-inference/tests/variables/mod.rs +++ b/type-inference/tests/variables/mod.rs @@ -18,32 +18,32 @@ use crate::TestTypeInference; #[test] fn test_duplicate_variable() { - let bytes = include_bytes!("duplicate_variable.leo"); - let check = TestTypeInference::new(bytes); + let program_string = include_str!("duplicate_variable.leo"); + let check = TestTypeInference::new(program_string); check.expect_error(); } #[test] fn test_duplicate_variable_multi() { - let bytes = include_bytes!("duplicate_variable_multi.leo"); - let check = TestTypeInference::new(bytes); + let program_string = include_str!("duplicate_variable_multi.leo"); + let check = TestTypeInference::new(program_string); check.expect_error(); } #[test] fn test_not_enough_values() { - let bytes = include_bytes!("not_enough_values.leo"); - let check = TestTypeInference::new(bytes); + let program_string = include_str!("not_enough_values.leo"); + let check = TestTypeInference::new(program_string); check.expect_error(); } #[test] fn test_too_many_values() { - let bytes = include_bytes!("too_many_values.leo"); - let check = TestTypeInference::new(bytes); + let program_string = include_str!("too_many_values.leo"); + let check = TestTypeInference::new(program_string); check.expect_error(); } From 5d2136b5187d347242110298fba9d075f02f70ed Mon Sep 17 00:00:00 2001 From: collin Date: Mon, 7 Dec 2020 12:05:55 -0500 Subject: [PATCH 08/17] use index map in ast module --- ast/Cargo.toml | 4 ++++ ast/src/annotation.rs | 12 +++++------ ast/src/input/macros.rs | 6 +++--- ast/src/input/program_input/main_input.rs | 5 +++-- ast/src/input/program_input/registers.rs | 2 +- .../program_state/private_state/record.rs | 2 +- .../program_state/private_state/state_leaf.rs | 2 +- .../input/program_state/public_state/state.rs | 2 +- ast/src/program.rs | 21 +++++++++---------- 9 files changed, 30 insertions(+), 26 deletions(-) diff --git a/ast/Cargo.toml b/ast/Cargo.toml index eec77394f0..06c5d997ac 100644 --- a/ast/Cargo.toml +++ b/ast/Cargo.toml @@ -42,6 +42,10 @@ default-features = false version = "1.1.3" default-features = false +[dependencies.indexmap] +version = "1.6.0" +features = ["serde-1"] + [dependencies.pest] version = "2.0" diff --git a/ast/src/annotation.rs b/ast/src/annotation.rs index 2a882c1fc0..50348b7dfe 100644 --- a/ast/src/annotation.rs +++ b/ast/src/annotation.rs @@ -20,14 +20,14 @@ use leo_grammar::{ definitions::{AnnotatedDefinition, Definition}, }; -use std::collections::HashMap; +use indexmap::IndexMap; pub fn load_annotation( annotated_definition: AnnotatedDefinition, _imports: &mut Vec, - _circuits: &mut HashMap, - _functions: &mut HashMap, - tests: &mut HashMap, + _circuits: &mut IndexMap, + _functions: &mut IndexMap, + tests: &mut IndexMap, _expected: &mut Vec, ) { let ast_annotation = annotated_definition.annotation; @@ -45,7 +45,7 @@ pub fn load_annotation( } } -pub fn load_annotated_test(test: TestFunction, annotation: Annotation, tests: &mut HashMap) { +pub fn load_annotated_test(test: TestFunction, annotation: Annotation, tests: &mut IndexMap) { let name = annotation.name; let ast_arguments = annotation.arguments; @@ -57,7 +57,7 @@ pub fn load_annotated_test(test: TestFunction, annotation: Annotation, tests: &m pub fn load_annotated_test_context( mut test: TestFunction, ast_arguments: AnnotationArguments, - tests: &mut HashMap, + tests: &mut IndexMap, ) { let arguments = ast_arguments.arguments; diff --git a/ast/src/input/macros.rs b/ast/src/input/macros.rs index 16276d4e1d..75a04d8f3e 100644 --- a/ast/src/input/macros.rs +++ b/ast/src/input/macros.rs @@ -22,7 +22,7 @@ macro_rules! input_section_impl { #[derive(Clone, PartialEq, Eq, Default)] pub struct $name { is_present: bool, - values: HashMap>, + values: IndexMap>, } impl $name { @@ -63,8 +63,8 @@ macro_rules! input_section_impl { Ok(()) } - /// Returns this section's hashmap of values - pub fn values(&self) -> HashMap> { + /// Returns this section's [IndexMap] of values + pub fn values(&self) -> IndexMap> { self.values.clone() } } diff --git a/ast/src/input/program_input/main_input.rs b/ast/src/input/program_input/main_input.rs index 26f77c7400..d930a0b050 100644 --- a/ast/src/input/program_input/main_input.rs +++ b/ast/src/input/program_input/main_input.rs @@ -16,11 +16,12 @@ use crate::InputValue; use leo_input::{definitions::Definition, InputParserError}; -use std::collections::HashMap; + +use indexmap::IndexMap; #[derive(Clone, PartialEq, Eq, Default)] pub struct MainInput { - input: HashMap>, + input: IndexMap>, } #[allow(clippy::len_without_is_empty)] diff --git a/ast/src/input/program_input/registers.rs b/ast/src/input/program_input/registers.rs index e3d7217d4c..e0981602ad 100644 --- a/ast/src/input/program_input/registers.rs +++ b/ast/src/input/program_input/registers.rs @@ -17,6 +17,6 @@ use crate::{InputValue, Parameter}; use leo_input::{definitions::Definition, InputParserError}; -use std::collections::HashMap; +use indexmap::IndexMap; input_section_impl!(Registers); diff --git a/ast/src/input/program_state/private_state/record.rs b/ast/src/input/program_state/private_state/record.rs index f2e1645449..0aef9d50e1 100644 --- a/ast/src/input/program_state/private_state/record.rs +++ b/ast/src/input/program_state/private_state/record.rs @@ -17,6 +17,6 @@ use crate::{InputValue, Parameter}; use leo_input::{definitions::Definition, InputParserError}; -use std::collections::HashMap; +use indexmap::IndexMap; input_section_impl!(Record); diff --git a/ast/src/input/program_state/private_state/state_leaf.rs b/ast/src/input/program_state/private_state/state_leaf.rs index e66c51f0ab..2fd1c01d72 100644 --- a/ast/src/input/program_state/private_state/state_leaf.rs +++ b/ast/src/input/program_state/private_state/state_leaf.rs @@ -17,6 +17,6 @@ use crate::{InputValue, Parameter}; use leo_input::{definitions::Definition, InputParserError}; -use std::collections::HashMap; +use indexmap::IndexMap; input_section_impl!(StateLeaf); diff --git a/ast/src/input/program_state/public_state/state.rs b/ast/src/input/program_state/public_state/state.rs index e6afcb7d6e..04b1a37923 100644 --- a/ast/src/input/program_state/public_state/state.rs +++ b/ast/src/input/program_state/public_state/state.rs @@ -17,6 +17,6 @@ use crate::{InputValue, Parameter}; use leo_input::{definitions::Definition, InputParserError}; -use std::collections::HashMap; +use indexmap::IndexMap; input_section_impl!(State); diff --git a/ast/src/program.rs b/ast/src/program.rs index ac016363e5..4794267217 100644 --- a/ast/src/program.rs +++ b/ast/src/program.rs @@ -20,18 +20,17 @@ use crate::{load_annotation, Circuit, Function, FunctionInput, Identifier, ImportStatement, TestFunction}; use leo_grammar::{definitions::Definition, files::File}; +use indexmap::IndexMap; use serde::{Deserialize, Serialize}; -use std::collections::HashMap; - /// Stores the Leo program abstract syntax tree. #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)] pub struct Program { pub name: String, pub expected_input: Vec, pub imports: Vec, - pub circuits: HashMap, - pub functions: HashMap, - pub tests: HashMap, + pub circuits: IndexMap, + pub functions: IndexMap, + pub tests: IndexMap, } const MAIN_FUNCTION_NAME: &str = "main"; @@ -40,9 +39,9 @@ impl<'ast> Program { //! Logic to convert from an abstract syntax tree (ast) representation to a Leo program. pub fn from(program_name: &str, program_ast: &File<'ast>) -> Self { let mut imports = vec![]; - let mut circuits = HashMap::new(); - let mut functions = HashMap::new(); - let mut tests = HashMap::new(); + let mut circuits = IndexMap::new(); + let mut functions = IndexMap::new(); + let mut tests = IndexMap::new(); let mut expected_input = vec![]; program_ast @@ -94,9 +93,9 @@ impl Program { name, expected_input: vec![], imports: vec![], - circuits: HashMap::new(), - functions: HashMap::new(), - tests: HashMap::new(), + circuits: IndexMap::new(), + functions: IndexMap::new(), + tests: IndexMap::new(), } } From ae6ee186ade3579db8487a2d93708b07bb916410 Mon Sep 17 00:00:00 2001 From: collin Date: Mon, 7 Dec 2020 12:10:42 -0500 Subject: [PATCH 09/17] use index map in imports module --- imports/Cargo.toml | 4 ++++ imports/src/parser/import_parser.rs | 10 ++++------ 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/imports/Cargo.toml b/imports/Cargo.toml index 3a4bd13771..909269250f 100644 --- a/imports/Cargo.toml +++ b/imports/Cargo.toml @@ -25,6 +25,10 @@ version = "1.0.6" path = "../grammar" version = "1.0.6" +[dependencies.indexmap] +version = "1.6.0" +features = ["serde-1"] + [dependencies.thiserror] version = "1.0" diff --git a/imports/src/parser/import_parser.rs b/imports/src/parser/import_parser.rs index 2466448ec9..3b4dc2fe7b 100644 --- a/imports/src/parser/import_parser.rs +++ b/imports/src/parser/import_parser.rs @@ -17,10 +17,8 @@ use crate::errors::ImportParserError; use leo_ast::{Package, Program}; -use std::{ - collections::{HashMap, HashSet}, - env::current_dir, -}; +use indexmap::{IndexMap, IndexSet}; +use std::env::current_dir; /// Stores imported packages. /// @@ -28,8 +26,8 @@ use std::{ /// directory, foreign in the imports directory, or part of the core package list. #[derive(Clone, Default)] pub struct ImportParser { - imports: HashMap, - core_packages: HashSet, + imports: IndexMap, + core_packages: IndexSet, } impl ImportParser { From bcaf7d3e666dc45c49611faa0f27afef116bc099 Mon Sep 17 00:00:00 2001 From: collin Date: Mon, 7 Dec 2020 12:12:31 -0500 Subject: [PATCH 10/17] use index map in state module --- state/Cargo.toml | 4 ++++ state/src/utilities/input_value.rs | 4 ++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/state/Cargo.toml b/state/Cargo.toml index e2a3f143ea..5e08e52011 100644 --- a/state/Cargo.toml +++ b/state/Cargo.toml @@ -52,6 +52,10 @@ default-features = false [dependencies.snarkos-utilities] version = "1.1.3" +[dependencies.indexmap] +version = "1.6.0" +features = ["serde-1"] + [dependencies.rand] version = "0.7" diff --git a/state/src/utilities/input_value.rs b/state/src/utilities/input_value.rs index 63da26329d..a6ad950ce8 100644 --- a/state/src/utilities/input_value.rs +++ b/state/src/utilities/input_value.rs @@ -17,13 +17,13 @@ use crate::InputValueError; use leo_ast::{InputValue, Parameter}; -use std::collections::HashMap; +use indexmap::IndexMap; /// Returns the input parameter with the given name. /// If a parameter with the given name does not exist, then an error is returned. pub fn find_input( name: String, - parameters: &HashMap>, + parameters: &IndexMap>, ) -> Result { let matched_parameter = parameters .iter() From 6797a1e046f518c8dd7269daf54e546f64b5ea3c Mon Sep 17 00:00:00 2001 From: collin Date: Mon, 7 Dec 2020 12:15:32 -0500 Subject: [PATCH 11/17] use index map in symbol-table module --- symbol-table/Cargo.toml | 4 ++++ symbol-table/src/symbol_table.rs | 21 ++++++++++++--------- symbol-table/src/types/circuits/circuit.rs | 9 ++++----- 3 files changed, 20 insertions(+), 14 deletions(-) diff --git a/symbol-table/Cargo.toml b/symbol-table/Cargo.toml index 809f0de36f..aa9f5e1a50 100644 --- a/symbol-table/Cargo.toml +++ b/symbol-table/Cargo.toml @@ -33,6 +33,10 @@ version = "1.0.6" path = "../imports" version = "1.0.6" +[dependencies.indexmap] +version = "1.6.0" +features = ["serde-1"] + [dependencies.serde] version = "1.0" diff --git a/symbol-table/src/symbol_table.rs b/symbol-table/src/symbol_table.rs index 0e5a56b121..9c58914ada 100644 --- a/symbol-table/src/symbol_table.rs +++ b/symbol-table/src/symbol_table.rs @@ -19,7 +19,7 @@ use leo_ast::{Circuit, Function, Identifier, ImportStatement, ImportSymbol, Inpu use leo_core::CorePackageList; use leo_imports::ImportParser; -use std::collections::{HashMap, HashSet}; +use indexmap::{IndexMap, IndexSet}; pub const INPUT_VARIABLE_NAME: &str = "input"; pub const RECORD_VARIABLE_NAME: &str = "record"; @@ -35,13 +35,13 @@ pub const STATE_LEAF_VARIABLE_NAME: &str = "state_leaf"; #[derive(Clone, Default)] pub struct SymbolTable { /// Maps name -> parameter type. - names: HashMap, + names: IndexMap, /// Maps circuit name -> circuit type. - circuits: HashMap, + circuits: IndexMap, /// Maps function name -> function type. - functions: HashMap, + functions: IndexMap, /// The parent of this symbol table. parent: Option>, @@ -214,7 +214,7 @@ impl SymbolTable { /// If a circuit name has no duplicates, then it is inserted into the symbol table. /// Types defined later in the program cannot have the same name. /// - pub fn check_circuit_names(&mut self, circuits: &HashMap) -> Result<(), SymbolTableError> { + pub fn check_circuit_names(&mut self, circuits: &IndexMap) -> Result<(), SymbolTableError> { // Iterate over circuit names and definitions. for (identifier, circuit) in circuits.iter() { // Attempt to insert the circuit name into the symbol table. @@ -230,7 +230,7 @@ impl SymbolTable { /// If a function name has no duplicates, then it is inserted into the symbol table. /// Types defined later in the program cannot have the same name. /// - pub fn check_function_names(&mut self, functions: &HashMap) -> Result<(), SymbolTableError> { + pub fn check_function_names(&mut self, functions: &IndexMap) -> Result<(), SymbolTableError> { // Iterate over function names and definitions. for (identifier, function) in functions.iter() { // Attempt to insert the function name into the symbol table. @@ -326,7 +326,7 @@ impl SymbolTable { // Import all symbols from an imported file for now. // Keep track of which import files have already been checked. - let mut checked = HashSet::new(); + let mut checked = IndexSet::new(); // Iterate over each imported symbol. for (name, symbol) in imported_symbols.symbols { @@ -416,7 +416,7 @@ impl SymbolTable { /// symbol table. Variables defined later in the program can lookup the definition /// and refer to its expected types /// - pub fn check_types_circuits(&mut self, circuits: &HashMap) -> Result<(), SymbolTableError> { + pub fn check_types_circuits(&mut self, circuits: &IndexMap) -> Result<(), SymbolTableError> { // Iterate over circuit names and definitions. for circuit in circuits.values() { // Get the identifier of the circuit. @@ -439,7 +439,10 @@ impl SymbolTable { /// symbol table. Variables defined later in the program can lookup the definition /// and refer to its expected types /// - pub fn check_types_functions(&mut self, functions: &HashMap) -> Result<(), SymbolTableError> { + pub fn check_types_functions( + &mut self, + functions: &IndexMap, + ) -> Result<(), SymbolTableError> { // Iterate over function names and definitions. for function in functions.values() { // Get the identifier of the function. diff --git a/symbol-table/src/types/circuits/circuit.rs b/symbol-table/src/types/circuits/circuit.rs index 2e6ea923f0..688f35f4c0 100644 --- a/symbol-table/src/types/circuits/circuit.rs +++ b/symbol-table/src/types/circuits/circuit.rs @@ -25,10 +25,9 @@ use crate::{ use leo_ast::{Circuit, CircuitMember, Identifier, InputValue, Parameter, Span}; use serde::{Deserialize, Serialize}; -use std::{ - collections::HashMap, - hash::{Hash, Hasher}, -}; +use std::hash::{Hash, Hasher}; + +use indexmap::IndexMap; /// Stores circuit definition details. /// @@ -152,7 +151,7 @@ impl CircuitType { pub fn from_input_section( table: &SymbolTable, name: String, - section: HashMap>, + section: IndexMap>, ) -> Result { // Create a new `CircuitVariableType` for each section pair. let mut variables = Vec::new(); From 05effde9b4d31106dc6a3a3e3605c96b97612c63 Mon Sep 17 00:00:00 2001 From: collin Date: Mon, 7 Dec 2020 12:17:26 -0500 Subject: [PATCH 12/17] use index map in type-inference module --- type-inference/Cargo.toml | 4 ++++ type-inference/src/objects/variable_table.rs | 7 ++++--- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/type-inference/Cargo.toml b/type-inference/Cargo.toml index 4728d0e3d9..2841ba3f58 100644 --- a/type-inference/Cargo.toml +++ b/type-inference/Cargo.toml @@ -33,6 +33,10 @@ version = "1.0.6" path = "../symbol-table" version = "1.0.6" +[dependencies.indexmap] +version = "1.6.0" +features = ["serde-1"] + [dependencies.serde_json] version = "1.0" diff --git a/type-inference/src/objects/variable_table.rs b/type-inference/src/objects/variable_table.rs index c48dcff583..9d15007cf3 100644 --- a/type-inference/src/objects/variable_table.rs +++ b/type-inference/src/objects/variable_table.rs @@ -16,11 +16,12 @@ use crate::VariableTableError; use leo_symbol_table::{FunctionInputType, Type}; -use std::collections::HashMap; + +use indexmap::IndexMap; /// Mapping of variable names to types #[derive(Clone)] -pub struct VariableTable(pub HashMap); +pub struct VariableTable(pub IndexMap); impl VariableTable { /// @@ -67,6 +68,6 @@ impl VariableTable { impl Default for VariableTable { fn default() -> Self { - Self(HashMap::new()) + Self(IndexMap::new()) } } From 1dbdf23d5a8cfbe98fed9d1681c20af93a83612d Mon Sep 17 00:00:00 2001 From: collin Date: Mon, 7 Dec 2020 12:18:20 -0500 Subject: [PATCH 13/17] use index map in compiler module --- Cargo.lock | 7 +++++++ compiler/Cargo.toml | 4 ++++ compiler/src/function/input/input_section.rs | 7 ++++--- compiler/src/program/program.rs | 6 +++--- symbol-table/src/types/circuits/circuit.rs | 3 +-- 5 files changed, 19 insertions(+), 8 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index d04a8d65f7..7a4b8c47b5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1153,6 +1153,7 @@ checksum = "55e2e4c765aa53a0424761bf9f41aa7a6ac1efa87238f59560640e27fca028f2" dependencies = [ "autocfg", "hashbrown", + "serde", ] [[package]] @@ -1299,6 +1300,7 @@ name = "leo-ast" version = "1.0.6" dependencies = [ "criterion", + "indexmap", "leo-grammar", "leo-input", "pest", @@ -1314,6 +1316,7 @@ version = "1.0.6" dependencies = [ "bincode", "hex", + "indexmap", "leo-ast", "leo-core", "leo-gadgets", @@ -1392,6 +1395,7 @@ dependencies = [ name = "leo-imports" version = "1.0.6" dependencies = [ + "indexmap", "leo-ast", "leo-grammar", "thiserror", @@ -1478,6 +1482,7 @@ dependencies = [ name = "leo-state" version = "1.0.6" dependencies = [ + "indexmap", "leo-ast", "leo-input", "rand", @@ -1497,6 +1502,7 @@ dependencies = [ name = "leo-symbol-table" version = "1.0.6" dependencies = [ + "indexmap", "leo-ast", "leo-core", "leo-grammar", @@ -1509,6 +1515,7 @@ dependencies = [ name = "leo-type-inference" version = "1.0.6" dependencies = [ + "indexmap", "leo-ast", "leo-grammar", "leo-imports", diff --git a/compiler/Cargo.toml b/compiler/Cargo.toml index cbf0636741..fe242bf7d0 100644 --- a/compiler/Cargo.toml +++ b/compiler/Cargo.toml @@ -90,6 +90,10 @@ version = "1.0" [dependencies.hex] version = "0.4.2" +[dependencies.indexmap] +version = "1.6.0" +features = ["serde-1"] + [dependencies.pest] version = "2.0" diff --git a/compiler/src/function/input/input_section.rs b/compiler/src/function/input/input_section.rs index 88b3e77da6..c33bc39636 100644 --- a/compiler/src/function/input/input_section.rs +++ b/compiler/src/function/input/input_section.rs @@ -15,20 +15,21 @@ // along with the Leo library. If not, see . use crate::{errors::FunctionError, ConstrainedCircuitMember, ConstrainedProgram, ConstrainedValue, GroupType}; - use leo_ast::{Identifier, InputValue, Parameter}; + use snarkos_models::{ curves::{Field, PrimeField}, gadgets::r1cs::ConstraintSystem, }; -use std::collections::HashMap; + +use indexmap::IndexMap; impl> ConstrainedProgram { pub fn allocate_input_section>( &mut self, cs: &mut CS, identifier: Identifier, - section: HashMap>, + section: IndexMap>, ) -> Result, FunctionError> { let mut members = Vec::with_capacity(section.len()); diff --git a/compiler/src/program/program.rs b/compiler/src/program/program.rs index 596c59b23e..75f36f4677 100644 --- a/compiler/src/program/program.rs +++ b/compiler/src/program/program.rs @@ -20,16 +20,16 @@ use crate::{value::ConstrainedValue, GroupType}; use snarkos_models::curves::{Field, PrimeField}; -use std::collections::HashMap; +use indexmap::IndexMap; pub struct ConstrainedProgram> { - pub identifiers: HashMap>, + pub identifiers: IndexMap>, } impl> Default for ConstrainedProgram { fn default() -> Self { Self { - identifiers: HashMap::new(), + identifiers: IndexMap::new(), } } } diff --git a/symbol-table/src/types/circuits/circuit.rs b/symbol-table/src/types/circuits/circuit.rs index 688f35f4c0..53ca088aad 100644 --- a/symbol-table/src/types/circuits/circuit.rs +++ b/symbol-table/src/types/circuits/circuit.rs @@ -24,11 +24,10 @@ use crate::{ }; use leo_ast::{Circuit, CircuitMember, Identifier, InputValue, Parameter, Span}; +use indexmap::IndexMap; use serde::{Deserialize, Serialize}; use std::hash::{Hash, Hasher}; -use indexmap::IndexMap; - /// Stores circuit definition details. /// /// This type should be added to the circuit symbol table for a resolved syntax tree. From b7e5cd13df992d5884dcad2ad08e4b2699a3ba3a Mon Sep 17 00:00:00 2001 From: collin Date: Tue, 8 Dec 2020 10:47:07 -0500 Subject: [PATCH 14/17] fix failing test --- compiler/tests/circuits/member_static_function_invalid.leo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/tests/circuits/member_static_function_invalid.leo b/compiler/tests/circuits/member_static_function_invalid.leo index 513d78b67d..09fec386d9 100644 --- a/compiler/tests/circuits/member_static_function_invalid.leo +++ b/compiler/tests/circuits/member_static_function_invalid.leo @@ -5,5 +5,5 @@ circuit Foo { } function main() { - let err = Foo::echo(1u32); // Correct, echo is a static function and must be accessed using `::` + let err = Foo.echo(1u32); // Invalid, echo is a static function and must be accessed using `::` } \ No newline at end of file From 8541eb3fb8199ec883472c779c1de8249e41a721 Mon Sep 17 00:00:00 2001 From: Collin Chin Date: Tue, 8 Dec 2020 12:21:18 -0500 Subject: [PATCH 15/17] Update mod.rs --- compiler/tests/function/mod.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/compiler/tests/function/mod.rs b/compiler/tests/function/mod.rs index 03a8b239d9..652964fafb 100644 --- a/compiler/tests/function/mod.rs +++ b/compiler/tests/function/mod.rs @@ -63,7 +63,7 @@ fn test_newlines() { #[test] fn test_multiple_returns() { - let program_string = include_str!("multiple.leo"); + let program_string = include_str!("multiple_returns.leo"); let program = parse_program(program_string).unwrap(); assert_satisfied(program); @@ -71,23 +71,23 @@ fn test_multiple_returns() { #[test] fn test_multiple_returns_fail() { - let bytes = include_bytes!("multiple_returns_fail.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("multiple_returns_fail.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_multiple_returns_fail_conditional() { - let bytes = include_bytes!("multiple_returns_fail_conditional.leo"); - let program = parse_program(bytes).unwrap(); + let program_string = include_str!("multiple_returns_fail_conditional.leo"); + let program = parse_program(program_string).unwrap(); expect_compiler_error(program); } #[test] fn test_multiple_returns_main() { - let program_string = include_str!("multiple_main.leo"); + let program_string = include_str!("multiple_returns_main.leo"); let input_string = include_str!("input/registers.in"); let program = parse_program_with_input(program_string, input_string).unwrap(); From 31d065154aa0484fcdca0f5fd6b768238e0373bc Mon Sep 17 00:00:00 2001 From: "dependabot-preview[bot]" <27856297+dependabot-preview[bot]@users.noreply.github.com> Date: Tue, 8 Dec 2020 22:05:22 +0000 Subject: [PATCH 16/17] Bump serde from 1.0.117 to 1.0.118 Bumps [serde](https://github.com/serde-rs/serde) from 1.0.117 to 1.0.118. - [Release notes](https://github.com/serde-rs/serde/releases) - [Commits](https://github.com/serde-rs/serde/compare/v1.0.117...v1.0.118) Signed-off-by: dependabot-preview[bot] --- Cargo.lock | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index bab77ee4e2..fe0b8bf847 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2455,9 +2455,9 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.117" +version = "1.0.118" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b88fa983de7720629c9387e9f517353ed404164b1e482c970a90c1a4aaf7dc1a" +checksum = "06c64263859d87aa2eb554587e2d23183398d617427327cf2b3d0ed8c69e4800" dependencies = [ "serde_derive", ] @@ -2474,9 +2474,9 @@ dependencies = [ [[package]] name = "serde_derive" -version = "1.0.117" +version = "1.0.118" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cbd1ae72adb44aab48f325a02444a5fc079349a8d804c1fc922aed3f7454c74e" +checksum = "c84d3526699cd55261af4b941e4e725444df67aa4f9e6a3564f18030d12672df" dependencies = [ "proc-macro2 1.0.24", "quote 1.0.7", From 7976650f1ef7e107685c6a75177d7a4572a2b6c3 Mon Sep 17 00:00:00 2001 From: "dependabot-preview[bot]" <27856297+dependabot-preview[bot]@users.noreply.github.com> Date: Wed, 9 Dec 2020 20:50:31 +0000 Subject: [PATCH 17/17] Bump zip from 0.5.8 to 0.5.9 Bumps [zip](https://github.com/mvdnes/zip-rs) from 0.5.8 to 0.5.9. - [Release notes](https://github.com/mvdnes/zip-rs/releases) - [Commits](https://github.com/mvdnes/zip-rs/compare/v0.5.8...v0.5.9) Signed-off-by: dependabot-preview[bot] --- Cargo.lock | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index bab77ee4e2..d6353a1e20 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3377,9 +3377,9 @@ dependencies = [ [[package]] name = "zip" -version = "0.5.8" +version = "0.5.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "543adf038106b64cfca4711c82c917d785e3540e04f7996554488f988ec43124" +checksum = "cc2896475a242c41366941faa27264df2cb935185a92e059a004d0048feb2ac5" dependencies = [ "byteorder", "bzip2",