From 827a3df815c027fff7bad9a1bb8a26f438899365 Mon Sep 17 00:00:00 2001 From: Jeff Date: Tue, 3 Dec 2024 14:27:48 -0500 Subject: [PATCH] Add math tests --- .../control_flow/comparison_expressions.rs | 409 ------------------ .../tests/control_flow/logic_expressions.rs | 34 -- dust-lang/tests/divide.rs | 33 -- dust-lang/tests/{add.rs => math_add.rs} | 0 .../{add_assign.rs => math_add_assign.rs} | 0 ...type_errors.rs => math_add_type_errors.rs} | 0 dust-lang/tests/math_divide.rs | 65 +++ ...divide_assign.rs => math_divide_assign.rs} | 0 dust-lang/tests/math_modulo.rs | 65 +++ .../{modulo.rs => math_modulo_assign.rs} | 0 dust-lang/tests/math_multiply.rs | 65 +++ ...iply_assign.rs => math_multiply_assign.rs} | 0 dust-lang/tests/math_subtract.rs | 65 +++ ...ract_assign.rs => math_subtract_assign.rs} | 0 dust-lang/tests/modulo_assign.rs | 0 dust-lang/tests/multiply.rs | 33 -- dust-lang/tests/subtract.rs | 33 -- 17 files changed, 260 insertions(+), 542 deletions(-) delete mode 100644 dust-lang/tests/control_flow/comparison_expressions.rs delete mode 100644 dust-lang/tests/control_flow/logic_expressions.rs delete mode 100644 dust-lang/tests/divide.rs rename dust-lang/tests/{add.rs => math_add.rs} (100%) rename dust-lang/tests/{add_assign.rs => math_add_assign.rs} (100%) rename dust-lang/tests/{add_type_errors.rs => math_add_type_errors.rs} (100%) create mode 100644 dust-lang/tests/math_divide.rs rename dust-lang/tests/{divide_assign.rs => math_divide_assign.rs} (100%) create mode 100644 dust-lang/tests/math_modulo.rs rename dust-lang/tests/{modulo.rs => math_modulo_assign.rs} (100%) create mode 100644 dust-lang/tests/math_multiply.rs rename dust-lang/tests/{multiply_assign.rs => math_multiply_assign.rs} (100%) create mode 100644 dust-lang/tests/math_subtract.rs rename dust-lang/tests/{subtract_assign.rs => math_subtract_assign.rs} (100%) delete mode 100644 dust-lang/tests/modulo_assign.rs delete mode 100644 dust-lang/tests/multiply.rs delete mode 100644 dust-lang/tests/subtract.rs diff --git a/dust-lang/tests/control_flow/comparison_expressions.rs b/dust-lang/tests/control_flow/comparison_expressions.rs deleted file mode 100644 index 31eb35f..0000000 --- a/dust-lang/tests/control_flow/comparison_expressions.rs +++ /dev/null @@ -1,409 +0,0 @@ -use dust_lang::*; - -#[test] -fn equality_assignment_long() { - let source = "let a = if 4 == 4 { true } else { false }; a"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::Boolean) - }, - vec![ - ( - *Instruction::equal(true, 0, 0) - .set_b_is_constant() - .set_c_is_constant(), - Span(13, 15) - ), - (Instruction::jump(1, true), Span(18, 19)), - (Instruction::load_boolean(0, true, true), Span(20, 24)), - (Instruction::load_boolean(0, false, false), Span(34, 39)), - (Instruction::define_local(0, 0, false), Span(4, 5)), - (Instruction::get_local(1, 0), Span(43, 44)), - (Instruction::r#return(true), Span(44, 44)), - ], - vec![ConcreteValue::Integer(4), ConcreteValue::string("a")], - vec![Local::new(1, Type::Boolean, false, Scope::default(),)] - )), - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true)))); -} - -#[test] -fn equality_assignment_short() { - let source = "let a = 4 == 4 a"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::Boolean) - }, - vec![ - ( - *Instruction::equal(true, 0, 0) - .set_b_is_constant() - .set_c_is_constant(), - Span(10, 12) - ), - (Instruction::jump(1, true), Span(10, 12)), - (Instruction::load_boolean(0, true, true), Span(10, 12)), - (Instruction::load_boolean(0, false, false), Span(10, 12)), - (Instruction::define_local(0, 0, false), Span(4, 5)), - (Instruction::get_local(1, 0), Span(15, 16)), - (Instruction::r#return(true), Span(16, 16)), - ], - vec![ConcreteValue::Integer(4), ConcreteValue::string("a")], - vec![Local::new(1, Type::Boolean, false, Scope::default())] - )), - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true)))); -} - -#[test] -fn if_else_assigment_false() { - let source = r#" - let a = if 4 == 3 { - panic(); - 0 - } else { - 1; 2; 3; 4; - 42 - }; - a"#; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::Integer) - }, - vec![ - ( - *Instruction::equal(true, 0, 1) - .set_b_is_constant() - .set_c_is_constant(), - Span(22, 24) - ), - (Instruction::jump(3, true), Span(27, 28)), - ( - Instruction::call_native(0, NativeFunction::Panic, 0), - Span(41, 48) - ), - (Instruction::load_constant(0, 2, false), Span(62, 63)), - (Instruction::jump(5, true), Span(129, 130)), - (Instruction::load_constant(1, 3, false), Span(93, 94)), - (Instruction::load_constant(2, 4, false), Span(96, 97)), - (Instruction::load_constant(3, 1, false), Span(99, 100)), - (Instruction::load_constant(4, 0, false), Span(102, 103)), - (Instruction::load_constant(5, 5, false), Span(117, 119)), - (Instruction::r#move(5, 0), Span(129, 130)), - (Instruction::define_local(5, 0, false), Span(13, 14)), - (Instruction::get_local(6, 0), Span(139, 140)), - (Instruction::r#return(true), Span(140, 140)), - ], - vec![ - ConcreteValue::Integer(4), - ConcreteValue::Integer(3), - ConcreteValue::Integer(0), - ConcreteValue::Integer(1), - ConcreteValue::Integer(2), - ConcreteValue::Integer(42), - ConcreteValue::string("a") - ], - vec![Local::new(6, Type::Integer, false, Scope::default())] - )), - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(42)))); -} - -#[test] -fn if_else_assigment_true() { - let source = r#" - let a = if 4 == 4 { - 1; 2; 3; 4; - 42 - } else { - panic(); - 0 - }; - a"#; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::Integer) - }, - vec![ - ( - *Instruction::equal(true, 0, 0) - .set_b_is_constant() - .set_c_is_constant(), - Span(22, 24) - ), - (Instruction::jump(6, true), Span(27, 28)), - (Instruction::load_constant(0, 1, false), Span(41, 42)), - (Instruction::load_constant(1, 2, false), Span(44, 45)), - (Instruction::load_constant(2, 3, false), Span(47, 48)), - (Instruction::load_constant(3, 0, false), Span(50, 51)), - (Instruction::load_constant(4, 4, false), Span(65, 67)), - (Instruction::jump(2, true), Span(129, 130)), - ( - Instruction::call_native(5, NativeFunction::Panic, 0), - Span(97, 104) - ), - (Instruction::load_constant(5, 5, false), Span(118, 119)), - (Instruction::r#move(5, 4), Span(129, 130)), - (Instruction::define_local(5, 0, false), Span(13, 14)), - (Instruction::get_local(6, 0), Span(139, 140)), - (Instruction::r#return(true), Span(140, 140)), - ], - vec![ - ConcreteValue::Integer(4), - ConcreteValue::Integer(1), - ConcreteValue::Integer(2), - ConcreteValue::Integer(3), - ConcreteValue::Integer(42), - ConcreteValue::Integer(0), - ConcreteValue::string("a") - ], - vec![Local::new(6, Type::Integer, false, Scope::default())] - )), - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(42)))); -} - -#[test] -fn if_else_complex() { - let source = " - if 1 == 1 { - 1; 2; 3; 4; - } else { - 1; 2; 3; 4; - }"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::None) - }, - vec![ - ( - *Instruction::equal(true, 0, 0) - .set_b_is_constant() - .set_c_is_constant(), - Span(14, 16) - ), - (Instruction::jump(5, true), Span(19, 20)), - (Instruction::load_constant(0, 0, false), Span(33, 34)), - (Instruction::load_constant(1, 1, false), Span(36, 37)), - (Instruction::load_constant(2, 2, false), Span(39, 40)), - (Instruction::load_constant(3, 3, false), Span(42, 43)), - (Instruction::jump(4, true), Span(95, 95)), - (Instruction::load_constant(4, 0, false), Span(74, 75)), - (Instruction::load_constant(5, 1, false), Span(77, 78)), - (Instruction::load_constant(6, 2, false), Span(80, 81)), - (Instruction::load_constant(7, 3, false), Span(83, 84)), - (Instruction::r#move(7, 3), Span(95, 95)), - (Instruction::r#return(false), Span(95, 95)), - ], - vec![ - ConcreteValue::Integer(1), - ConcreteValue::Integer(2), - ConcreteValue::Integer(3), - ConcreteValue::Integer(4), - ], - vec![] - )) - ); - - assert_eq!(run(source), Ok(None)); -} - -#[test] -fn if_else_false() { - let source = "if 1 == 2 { panic(); 0 } else { 42 }"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::Integer) - }, - vec![ - ( - *Instruction::equal(true, 0, 1) - .set_b_is_constant() - .set_c_is_constant(), - Span(5, 7) - ), - (Instruction::jump(2, true), Span(10, 11)), - ( - Instruction::call_native(0, NativeFunction::Panic, 0), - Span(12, 19) - ), - (Instruction::load_constant(0, 2, true), Span(21, 22)), - (Instruction::load_constant(1, 3, false), Span(32, 34)), - (Instruction::r#move(1, 0), Span(36, 36)), - (Instruction::r#return(true), Span(36, 36)), - ], - vec![ - ConcreteValue::Integer(1), - ConcreteValue::Integer(2), - ConcreteValue::Integer(0), - ConcreteValue::Integer(42) - ], - vec![] - )), - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(42)))); -} - -#[test] -fn if_else_true() { - let source = "if 1 == 1 { 42 } else { panic(); 0 }"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::Integer) - }, - vec![ - ( - *Instruction::equal(true, 0, 0) - .set_b_is_constant() - .set_c_is_constant(), - Span(5, 7) - ), - (Instruction::jump(2, true), Span(10, 11)), - (Instruction::load_constant(0, 1, false), Span(12, 14)), - (Instruction::jump(2, true), Span(36, 36)), - ( - Instruction::call_native(1, NativeFunction::Panic, 0), - Span(24, 31) - ), - (Instruction::load_constant(1, 2, false), Span(33, 34)), - (Instruction::r#move(1, 0), Span(36, 36)), - (Instruction::r#return(true), Span(36, 36)) - ], - vec![ - ConcreteValue::Integer(1), - ConcreteValue::Integer(42), - ConcreteValue::Integer(0) - ], - vec![] - )), - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(42)))); -} - -#[test] -fn if_false() { - let source = "if 1 == 2 { panic() }"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::None) - }, - vec![ - ( - *Instruction::equal(true, 0, 1) - .set_b_is_constant() - .set_c_is_constant(), - Span(5, 7) - ), - (Instruction::jump(1, true), Span(10, 11)), - ( - Instruction::call_native(0, NativeFunction::Panic, 0), - Span(12, 19) - ), - (Instruction::r#return(false), Span(21, 21)) - ], - vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)], - vec![] - )), - ); - - assert_eq!(run(source), Ok(None)); -} - -#[test] -fn if_true() { - let source = "if 1 == 1 { panic() }"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::None) - }, - vec![ - ( - *Instruction::equal(true, 0, 0) - .set_b_is_constant() - .set_c_is_constant(), - Span(5, 7) - ), - (Instruction::jump(1, true), Span(10, 11)), - ( - Instruction::call_native(0, NativeFunction::Panic, 0), - Span(12, 19) - ), - (Instruction::r#return(false), Span(21, 21)) - ], - vec![ConcreteValue::Integer(1)], - vec![] - )), - ); - - assert_eq!( - run(source), - Err(DustError::Runtime { - error: VmError::NativeFunction(NativeFunctionError::Panic { - message: None, - position: Span(12, 19) - }), - source - }) - ); -} diff --git a/dust-lang/tests/control_flow/logic_expressions.rs b/dust-lang/tests/control_flow/logic_expressions.rs deleted file mode 100644 index a00b14c..0000000 --- a/dust-lang/tests/control_flow/logic_expressions.rs +++ /dev/null @@ -1,34 +0,0 @@ -#[test] -fn if_true() { - let source = "if true && true { 42 } else { 0 }"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::None) - }, - vec![ - ( - *Instruction::equal(true, 0, 0) - .set_b_is_constant() - .set_c_is_constant(), - Span(5, 7) - ), - (Instruction::jump(1, true), Span(10, 11)), - ( - Instruction::call_native(0, NativeFunction::Panic, 0), - Span(12, 19) - ), - (Instruction::r#return(false), Span(21, 21)) - ], - vec![ConcreteValue::Integer(1)], - vec![] - )), - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(42))),); -} diff --git a/dust-lang/tests/divide.rs b/dust-lang/tests/divide.rs deleted file mode 100644 index 428d2a0..0000000 --- a/dust-lang/tests/divide.rs +++ /dev/null @@ -1,33 +0,0 @@ -use dust_lang::*; - -#[test] -fn divide() { - let source = "2 / 2"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::Integer), - }, - vec![ - ( - Instruction::divide( - Destination::Register(0), - Argument::Constant(0), - Argument::Constant(0) - ), - Span(2, 3) - ), - (Instruction::r#return(true), Span(5, 5)) - ], - vec![ConcreteValue::Integer(2)], - vec![] - )) - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(1)))); -} diff --git a/dust-lang/tests/add.rs b/dust-lang/tests/math_add.rs similarity index 100% rename from dust-lang/tests/add.rs rename to dust-lang/tests/math_add.rs diff --git a/dust-lang/tests/add_assign.rs b/dust-lang/tests/math_add_assign.rs similarity index 100% rename from dust-lang/tests/add_assign.rs rename to dust-lang/tests/math_add_assign.rs diff --git a/dust-lang/tests/add_type_errors.rs b/dust-lang/tests/math_add_type_errors.rs similarity index 100% rename from dust-lang/tests/add_type_errors.rs rename to dust-lang/tests/math_add_type_errors.rs diff --git a/dust-lang/tests/math_divide.rs b/dust-lang/tests/math_divide.rs new file mode 100644 index 0000000..436179e --- /dev/null +++ b/dust-lang/tests/math_divide.rs @@ -0,0 +1,65 @@ +use dust_lang::*; + +#[test] +fn divide_floats() { + let source = "2.0 / 2.0"; + + assert_eq!( + compile(source), + Ok(Chunk::with_data( + None, + FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::Float), + }, + vec![ + ( + Instruction::divide( + Destination::Register(0), + Argument::Constant(0), + Argument::Constant(0) + ), + Span(4, 5) + ), + (Instruction::r#return(true), Span(9, 9)) + ], + vec![ConcreteValue::Float(2.0)], + vec![] + )) + ); + + assert_eq!(run(source), Ok(Some(ConcreteValue::Float(1.0)))); +} + +#[test] +fn divide_integers() { + let source = "2 / 2"; + + assert_eq!( + compile(source), + Ok(Chunk::with_data( + None, + FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::Integer), + }, + vec![ + ( + Instruction::divide( + Destination::Register(0), + Argument::Constant(0), + Argument::Constant(0) + ), + Span(2, 3) + ), + (Instruction::r#return(true), Span(5, 5)) + ], + vec![ConcreteValue::Integer(2)], + vec![] + )) + ); + + assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(1)))); +} diff --git a/dust-lang/tests/divide_assign.rs b/dust-lang/tests/math_divide_assign.rs similarity index 100% rename from dust-lang/tests/divide_assign.rs rename to dust-lang/tests/math_divide_assign.rs diff --git a/dust-lang/tests/math_modulo.rs b/dust-lang/tests/math_modulo.rs new file mode 100644 index 0000000..05d1da4 --- /dev/null +++ b/dust-lang/tests/math_modulo.rs @@ -0,0 +1,65 @@ +use dust_lang::*; + +#[test] +fn modulo_floats() { + let source = "2.0 % 2.0"; + + assert_eq!( + compile(source), + Ok(Chunk::with_data( + None, + FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::Float), + }, + vec![ + ( + Instruction::modulo( + Destination::Register(0), + Argument::Constant(0), + Argument::Constant(0) + ), + Span(4, 5) + ), + (Instruction::r#return(true), Span(9, 9)) + ], + vec![ConcreteValue::Float(2.0)], + vec![] + )) + ); + + assert_eq!(run(source), Ok(Some(ConcreteValue::Float(0.0)))); +} + +#[test] +fn modulo_integers() { + let source = "2 % 2"; + + assert_eq!( + compile(source), + Ok(Chunk::with_data( + None, + FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::Integer), + }, + vec![ + ( + Instruction::modulo( + Destination::Register(0), + Argument::Constant(0), + Argument::Constant(0) + ), + Span(2, 3) + ), + (Instruction::r#return(true), Span(5, 5)) + ], + vec![ConcreteValue::Integer(2)], + vec![] + )) + ); + + assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(0)))); +} diff --git a/dust-lang/tests/modulo.rs b/dust-lang/tests/math_modulo_assign.rs similarity index 100% rename from dust-lang/tests/modulo.rs rename to dust-lang/tests/math_modulo_assign.rs diff --git a/dust-lang/tests/math_multiply.rs b/dust-lang/tests/math_multiply.rs new file mode 100644 index 0000000..4436d95 --- /dev/null +++ b/dust-lang/tests/math_multiply.rs @@ -0,0 +1,65 @@ +use dust_lang::*; + +#[test] +fn multiply_floats() { + let source = "2.0 * 2.0"; + + assert_eq!( + compile(source), + Ok(Chunk::with_data( + None, + FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::Float), + }, + vec![ + ( + Instruction::multiply( + Destination::Register(0), + Argument::Constant(0), + Argument::Constant(1) + ), + Span(4, 5) + ), + (Instruction::r#return(true), Span(9, 9)), + ], + vec![ConcreteValue::Float(2.0), ConcreteValue::Float(2.0)], + vec![] + )) + ); + + assert_eq!(run(source), Ok(Some(ConcreteValue::Float(4.0)))); +} + +#[test] +fn multiply_integers() { + let source = "1 * 2"; + + assert_eq!( + compile(source), + Ok(Chunk::with_data( + None, + FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::Integer), + }, + vec![ + ( + Instruction::multiply( + Destination::Register(0), + Argument::Constant(0), + Argument::Constant(1) + ), + Span(2, 3) + ), + (Instruction::r#return(true), Span(5, 5)), + ], + vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)], + vec![] + )) + ); + + assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(2)))); +} diff --git a/dust-lang/tests/multiply_assign.rs b/dust-lang/tests/math_multiply_assign.rs similarity index 100% rename from dust-lang/tests/multiply_assign.rs rename to dust-lang/tests/math_multiply_assign.rs diff --git a/dust-lang/tests/math_subtract.rs b/dust-lang/tests/math_subtract.rs new file mode 100644 index 0000000..57825ba --- /dev/null +++ b/dust-lang/tests/math_subtract.rs @@ -0,0 +1,65 @@ +use dust_lang::*; + +#[test] +fn subtract_floats() { + let source = "2.0 - 2.0"; + + assert_eq!( + compile(source), + Ok(Chunk::with_data( + None, + FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::Float), + }, + vec![ + ( + Instruction::subtract( + Destination::Register(0), + Argument::Constant(0), + Argument::Constant(0) + ), + Span(4, 5) + ), + (Instruction::r#return(true), Span(9, 9)), + ], + vec![ConcreteValue::Float(2.0)], + vec![] + )) + ); + + assert_eq!(run(source), Ok(Some(ConcreteValue::Float(0.0)))); +} + +#[test] +fn subtract_integers() { + let source = "1 - 2"; + + assert_eq!( + compile(source), + Ok(Chunk::with_data( + None, + FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::Integer), + }, + vec![ + ( + Instruction::subtract( + Destination::Register(0), + Argument::Constant(0), + Argument::Constant(1) + ), + Span(2, 3) + ), + (Instruction::r#return(true), Span(5, 5)), + ], + vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)], + vec![] + )) + ); + + assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(-1)))); +} diff --git a/dust-lang/tests/subtract_assign.rs b/dust-lang/tests/math_subtract_assign.rs similarity index 100% rename from dust-lang/tests/subtract_assign.rs rename to dust-lang/tests/math_subtract_assign.rs diff --git a/dust-lang/tests/modulo_assign.rs b/dust-lang/tests/modulo_assign.rs deleted file mode 100644 index e69de29..0000000 diff --git a/dust-lang/tests/multiply.rs b/dust-lang/tests/multiply.rs deleted file mode 100644 index 20c90bb..0000000 --- a/dust-lang/tests/multiply.rs +++ /dev/null @@ -1,33 +0,0 @@ -use dust_lang::*; - -#[test] -fn multiply() { - let source = "1 * 2"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::Integer), - }, - vec![ - ( - Instruction::multiply( - Destination::Register(0), - Argument::Constant(0), - Argument::Constant(1) - ), - Span(2, 3) - ), - (Instruction::r#return(true), Span(5, 5)), - ], - vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)], - vec![] - )) - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(2)))); -} diff --git a/dust-lang/tests/subtract.rs b/dust-lang/tests/subtract.rs deleted file mode 100644 index a2699eb..0000000 --- a/dust-lang/tests/subtract.rs +++ /dev/null @@ -1,33 +0,0 @@ -use dust_lang::*; - -#[test] -fn subtract() { - let source = "1 - 2"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Box::new(Type::Integer), - }, - vec![ - ( - Instruction::subtract( - Destination::Register(0), - Argument::Constant(0), - Argument::Constant(1) - ), - Span(2, 3) - ), - (Instruction::r#return(true), Span(5, 5)), - ], - vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)], - vec![] - )) - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(-1)))); -}