From dc3cc13b1272a67807c52eab8af7831d89bf06cc Mon Sep 17 00:00:00 2001 From: Jeff Date: Wed, 25 Dec 2024 10:04:35 -0500 Subject: [PATCH] Fix tests --- dust-lang/src/value/concrete_value.rs | 8 + dust-lang/src/value/mod.rs | 4 +- dust-lang/src/vm/run_action.rs | 10 +- dust-lang/tests/logic/and_and.rs | 32 +++- dust-lang/tests/logic/or.rs | 25 ++- dust-lang/tests/logic/variables.rs | 262 -------------------------- dust-lang/tests/math/add.rs | 155 +++++++-------- 7 files changed, 120 insertions(+), 376 deletions(-) delete mode 100644 dust-lang/tests/logic/variables.rs diff --git a/dust-lang/src/value/concrete_value.rs b/dust-lang/src/value/concrete_value.rs index 553d60d..8e455f7 100644 --- a/dust-lang/src/value/concrete_value.rs +++ b/dust-lang/src/value/concrete_value.rs @@ -82,6 +82,14 @@ impl ConcreteValue { String(concatenated) } + (Character(left), String(right)) => { + let mut concatenated = DustString::new(); + + concatenated.push(*left); + concatenated.push_str(right); + + String(concatenated) + } (Float(left), Float(right)) => { let sum = left + right; diff --git a/dust-lang/src/value/mod.rs b/dust-lang/src/value/mod.rs index 317a0fc..21a53de 100644 --- a/dust-lang/src/value/mod.rs +++ b/dust-lang/src/value/mod.rs @@ -46,8 +46,8 @@ impl Value { Value::Concrete(ConcreteValue::Integer(integer)) } - pub fn string(string: DustString) -> Self { - Value::Concrete(ConcreteValue::String(string)) + pub fn string(string: impl Into) -> Self { + Value::Concrete(ConcreteValue::String(string.into())) } pub fn as_boolean(&self) -> Option<&bool> { diff --git a/dust-lang/src/vm/run_action.rs b/dust-lang/src/vm/run_action.rs index 29f12c1..5a64256 100644 --- a/dust-lang/src/vm/run_action.rs +++ b/dust-lang/src/vm/run_action.rs @@ -232,15 +232,7 @@ pub fn add(instruction_data: InstructionData, record: &mut Record) -> ThreadSign } = instruction_data; let left = record.get_argument(b, b_is_constant); let right = record.get_argument(c, c_is_constant); - let sum = match (left, right) { - (Value::Concrete(left), Value::Concrete(right)) => match (left, right) { - (ConcreteValue::Integer(left), ConcreteValue::Integer(right)) => { - ConcreteValue::Integer(left + right).to_value() - } - _ => panic!("Value Error: Cannot add values"), - }, - _ => panic!("Value Error: Cannot add values {left} and {right}"), - }; + let sum = left.add(right); let register = Register::Value(sum); record.set_register(a, register); diff --git a/dust-lang/tests/logic/and_and.rs b/dust-lang/tests/logic/and_and.rs index 352753b..53c38ba 100644 --- a/dust-lang/tests/logic/and_and.rs +++ b/dust-lang/tests/logic/and_and.rs @@ -1,4 +1,5 @@ use dust_lang::*; +use smallvec::smallvec; #[test] fn true_and_true_and_true() { @@ -13,18 +14,29 @@ fn true_and_true_and_true() { value_parameters: None, return_type: Type::Boolean, }, - vec![ - (Instruction::load_boolean(0, true, false), Span(0, 4)), - (Instruction::test(Argument::Register(0), true), Span(5, 7)), - (Instruction::jump(1, true), Span(5, 7)), - (Instruction::load_boolean(1, true, false), Span(8, 12)), - (Instruction::test(Argument::Register(1), true), Span(13, 15)), - (Instruction::jump(1, true), Span(13, 15)), - (Instruction::load_boolean(2, true, false), Span(16, 20)), - (Instruction::r#return(true), Span(20, 20)), + smallvec![ + Instruction::load_boolean(0, true, false), + Instruction::test(0, true), + Instruction::jump(1, true), + Instruction::load_boolean(1, true, false), + Instruction::test(1, true), + Instruction::jump(1, true), + Instruction::load_boolean(2, true, false), + Instruction::r#return(true), ], + smallvec![ + Span(0, 4), + Span(5, 7), + Span(5, 7), + Span(8, 12), + Span(13, 15), + Span(13, 15), + Span(16, 20), + Span(20, 20) + ], + smallvec![], + smallvec![], vec![], - vec![] )) ); } diff --git a/dust-lang/tests/logic/or.rs b/dust-lang/tests/logic/or.rs index b62ed74..0886f23 100644 --- a/dust-lang/tests/logic/or.rs +++ b/dust-lang/tests/logic/or.rs @@ -1,4 +1,5 @@ use dust_lang::*; +use smallvec::smallvec; #[test] fn true_or_false() { @@ -13,17 +14,25 @@ fn true_or_false() { value_parameters: None, return_type: Type::Boolean, }, - vec![ - (Instruction::load_boolean(0, true, false), Span(0, 4)), - (Instruction::test(Argument::Register(0), false), Span(5, 7)), - (Instruction::jump(1, true), Span(5, 7)), - (Instruction::load_boolean(1, false, false), Span(8, 13)), - (Instruction::r#return(true), Span(13, 13)), + smallvec![ + Instruction::load_boolean(0, true, false), + Instruction::test(0, false), + Instruction::jump(1, true), + Instruction::load_boolean(1, false, false), + Instruction::r#return(true), ], - vec![], + smallvec![ + Span(0, 4), + Span(5, 7), + Span(5, 7), + Span(8, 13), + Span(13, 13), + ], + smallvec![], + smallvec![], vec![] )) ); - assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true)))); + assert_eq!(run(source), Ok(Some(Value::boolean(true)))); } diff --git a/dust-lang/tests/logic/variables.rs b/dust-lang/tests/logic/variables.rs deleted file mode 100644 index 208740a..0000000 --- a/dust-lang/tests/logic/variables.rs +++ /dev/null @@ -1,262 +0,0 @@ -use dust_lang::*; - -#[test] -fn true_and_true() { - let source = "let a = true; let b = true; a && b"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Type::Boolean, - }, - vec![ - (Instruction::load_boolean(0, true, false), Span(8, 12)), - (Instruction::load_boolean(1, true, false), Span(22, 26)), - (Instruction::get_local(2, 0), Span(28, 29)), - (Instruction::test(Argument::Register(0), true), Span(30, 32)), - (Instruction::jump(1, true), Span(30, 32)), - (Instruction::get_local(3, 1), Span(33, 34)), - (Instruction::r#return(true), Span(34, 34)), - ], - vec![ConcreteValue::string("a"), ConcreteValue::string("b")], - vec![ - Local::new(0, 0, false, Scope::default()), - Local::new(1, 1, false, Scope::default()) - ] - )) - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true)))); -} - -#[test] -fn false_and_false() { - let source = "let a = false; let b = false; a && b"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Type::Boolean, - }, - vec![ - (Instruction::load_boolean(0, false, false), Span(8, 13)), - (Instruction::load_boolean(1, false, false), Span(23, 28)), - (Instruction::get_local(2, 0), Span(30, 31)), - (Instruction::test(Argument::Register(0), true), Span(32, 34)), - (Instruction::jump(1, true), Span(32, 34)), - (Instruction::get_local(3, 1), Span(35, 36)), - (Instruction::r#return(true), Span(36, 36)), - ], - vec![ConcreteValue::string("a"), ConcreteValue::string("b")], - vec![ - Local::new(0, 0, false, Scope::default()), - Local::new(1, 0, false, Scope::default()) - ] - )) - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(false)))); -} - -#[test] -fn true_and_false() { - let source = "let a = true; let b = false; a && b"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Type::Boolean, - }, - vec![ - (Instruction::load_boolean(0, true, false), Span(8, 12)), - (Instruction::load_boolean(1, false, false), Span(22, 27)), - (Instruction::get_local(2, 0), Span(29, 30)), - (Instruction::test(Argument::Register(0), true), Span(31, 33)), - (Instruction::jump(1, true), Span(31, 33)), - (Instruction::get_local(3, 1), Span(34, 35)), - (Instruction::r#return(true), Span(35, 35)), - ], - vec![ConcreteValue::string("a"), ConcreteValue::string("b")], - vec![ - Local::new(0, 0, false, Scope::default()), - Local::new(1, 1, false, Scope::default()) - ] - )) - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(false)))); -} - -#[test] -fn false_and_true() { - let source = "let a = false; let b = true; a && b"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Type::Boolean, - }, - vec![ - (Instruction::load_boolean(0, false, false), Span(8, 13)), - (Instruction::load_boolean(1, true, false), Span(23, 27)), - (Instruction::get_local(2, 0), Span(29, 30)), - (Instruction::test(Argument::Register(0), true), Span(31, 33)), - (Instruction::jump(1, true), Span(31, 33)), - (Instruction::get_local(3, 1), Span(34, 35)), - (Instruction::r#return(true), Span(35, 35)), - ], - vec![ConcreteValue::string("a"), ConcreteValue::string("b")], - vec![ - Local::new(0, 0, false, Scope::default()), - Local::new(1, 1, false, Scope::default()) - ] - )) - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(false)))); -} - -#[test] -fn true_and_true_and_true() { - let source = "let a = true; let b = true; let c = true; a && b && c"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Type::Boolean, - }, - vec![ - (Instruction::load_boolean(0, true, false), Span(8, 12)), - (Instruction::load_boolean(1, true, false), Span(22, 26)), - (Instruction::load_boolean(2, true, false), Span(36, 40)), - (Instruction::get_local(3, 0), Span(42, 43)), - (Instruction::test(Argument::Register(0), true), Span(44, 46)), - (Instruction::jump(1, true), Span(44, 46)), - (Instruction::get_local(4, 1), Span(47, 48)), - (Instruction::test(Argument::Register(1), true), Span(49, 51)), - (Instruction::jump(1, true), Span(49, 51)), - (Instruction::get_local(5, 2), Span(52, 53)), - (Instruction::r#return(true), Span(53, 53)), - ], - vec![ - ConcreteValue::string("a"), - ConcreteValue::string("b"), - ConcreteValue::string("c") - ], - vec![ - Local::new(0, 0, false, Scope::default()), - Local::new(1, 1, false, Scope::default()), - Local::new(2, 2, false, Scope::default()) - ] - )) - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true)))); -} - -#[test] -fn false_and_false_and_false() { - let source = "let a = false; let b = false; let c = false; a && b && c"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Type::Boolean, - }, - vec![ - (Instruction::load_boolean(0, false, false), Span(8, 13)), - (Instruction::load_boolean(1, false, false), Span(23, 28)), - (Instruction::load_boolean(2, false, false), Span(38, 43)), - (Instruction::get_local(3, 0), Span(45, 46)), - (Instruction::test(Argument::Register(0), true), Span(47, 49)), - (Instruction::jump(1, true), Span(47, 49)), - (Instruction::get_local(4, 1), Span(50, 51)), - (Instruction::test(Argument::Register(1), true), Span(52, 54)), - (Instruction::jump(1, true), Span(52, 54)), - (Instruction::get_local(5, 2), Span(55, 56)), - (Instruction::r#return(true), Span(56, 56)), - ], - vec![ - ConcreteValue::string("a"), - ConcreteValue::string("b"), - ConcreteValue::string("c") - ], - vec![ - Local::new(0, 0, false, Scope::default()), - Local::new(1, 1, false, Scope::default()), - Local::new(2, 2, false, Scope::default()) - ] - )) - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(false)))); -} - -#[test] -fn true_and_true_or_false() { - let source = "let a = true; let b = true; let c = false; a && b || c"; - - assert_eq!( - compile(source), - Ok(Chunk::with_data( - None, - FunctionType { - type_parameters: None, - value_parameters: None, - return_type: Type::Boolean, - }, - vec![ - (Instruction::load_boolean(0, true, false), Span(8, 12)), - (Instruction::load_boolean(1, true, false), Span(22, 26)), - (Instruction::load_boolean(2, false, false), Span(36, 41)), - (Instruction::get_local(3, 0), Span(43, 44)), - (Instruction::test(Argument::Register(0), true), Span(45, 47)), - (Instruction::jump(1, true), Span(45, 47)), - (Instruction::get_local(4, 1), Span(48, 49)), - ( - Instruction::test(Argument::Register(1), false), - Span(50, 52) - ), - (Instruction::jump(1, true), Span(50, 52)), - (Instruction::get_local(5, 2), Span(53, 54)), - (Instruction::r#return(true), Span(54, 54)), - ], - vec![ - ConcreteValue::string("a"), - ConcreteValue::string("b"), - ConcreteValue::string("c") - ], - vec![ - Local::new(0, 0, false, Scope::default()), - Local::new(1, 1, false, Scope::default()), - Local::new(2, 2, false, Scope::default()) - ] - )) - ); - - assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true)))); -} diff --git a/dust-lang/tests/math/add.rs b/dust-lang/tests/math/add.rs index 21e916e..59c77cf 100644 --- a/dust-lang/tests/math/add.rs +++ b/dust-lang/tests/math/add.rs @@ -1,4 +1,5 @@ use dust_lang::*; +use smallvec::smallvec; #[test] fn add_bytes() { @@ -13,19 +14,18 @@ fn add_bytes() { value_parameters: None, return_type: Type::Byte, }, - vec![ - ( - Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), - Span(5, 6) - ), - (Instruction::r#return(true), Span(11, 11)) + smallvec![ + Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), + Instruction::r#return(true), ], - vec![ConcreteValue::Byte(0xfe), ConcreteValue::Byte(0x01)], + smallvec![Span(5, 6), Span(11, 11),], + smallvec![Value::byte(0xfe), Value::byte(0x01)], + smallvec![], vec![] )) ); - assert_eq!(run(source), Ok(Some(ConcreteValue::Byte(0xff)))); + assert_eq!(run(source), Ok(Some(Value::byte(0xff)))); } #[test] @@ -41,19 +41,18 @@ fn add_bytes_saturate() { value_parameters: None, return_type: Type::Byte, }, - vec![ - ( - Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), - Span(5, 6) - ), - (Instruction::r#return(true), Span(11, 11)) + smallvec![ + Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), + Instruction::r#return(true), ], - vec![ConcreteValue::Byte(0xff), ConcreteValue::Byte(0x01)], + smallvec![Span(5, 6), Span(11, 11)], + smallvec![Value::byte(0xff), Value::byte(0x01)], + smallvec![], vec![] )) ); - assert_eq!(run(source), Ok(Some(ConcreteValue::Byte(0xff)))); + assert_eq!(run(source), Ok(Some(Value::byte(0xff)))); } #[test] @@ -69,19 +68,18 @@ fn add_characters() { value_parameters: None, return_type: Type::String, }, - vec![ - ( - Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), - Span(4, 5) - ), - (Instruction::r#return(true), Span(9, 9)) + smallvec![ + Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), + Instruction::r#return(true) ], - vec![ConcreteValue::Character('a'), ConcreteValue::Character('b')], + smallvec![Span(4, 5), Span(11, 11)], + smallvec![Value::character('a'), Value::character('b')], + smallvec![], vec![] )) ); - assert_eq!(run(source), Ok(Some(ConcreteValue::string("ab")))); + assert_eq!(run(source), Ok(Some(Value::string("ab")))); } #[test] @@ -97,19 +95,18 @@ fn add_character_and_string() { value_parameters: None, return_type: Type::String, }, - vec![ - ( - Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), - Span(4, 5) - ), - (Instruction::r#return(true), Span(9, 9)) + smallvec![ + Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), + Instruction::r#return(true), ], - vec![ConcreteValue::Character('a'), ConcreteValue::string("b")], + smallvec![Span(4, 5), Span(9, 9),], + smallvec![Value::character('a'), Value::string("b")], + smallvec![], vec![] )) ); - assert_eq!(run(source), Ok(Some(ConcreteValue::string("ab")))); + assert_eq!(run(source), Ok(Some(Value::string("ab")))); } #[test] @@ -125,19 +122,18 @@ fn add_floats() { value_parameters: None, return_type: Type::Float, }, - vec![ - ( - Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), - Span(4, 5) - ), - (Instruction::r#return(true), Span(9, 9)) + smallvec![ + Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), + Instruction::r#return(true), ], - vec![ConcreteValue::Float(1.0), ConcreteValue::Float(2.0)], + smallvec![Span(4, 5), Span(9, 9),], + smallvec![Value::float(1.0), Value::float(2.0)], + smallvec![], vec![] )) ); - assert_eq!(run(source), Ok(Some(ConcreteValue::Float(3.0)))); + assert_eq!(run(source), Ok(Some(Value::float(3.0)))); } #[test] @@ -153,22 +149,18 @@ fn add_floats_saturatate() { value_parameters: None, return_type: Type::Float, }, - vec![ - ( - Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), - Span(24, 25) - ), - (Instruction::r#return(true), Span(36, 36)) - ], - vec![ - ConcreteValue::Float(f64::MAX), - ConcreteValue::Float(0.00000001) + smallvec![ + Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), + Instruction::r#return(true), ], + smallvec![Span(24, 25), Span(36, 36),], + smallvec![Value::float(f64::MAX), Value::float(0.00000001)], + smallvec![], vec![] )) ); - assert_eq!(run(source), Ok(Some(ConcreteValue::Float(f64::MAX)))); + assert_eq!(run(source), Ok(Some(Value::float(f64::MAX)))); } #[test] @@ -184,19 +176,18 @@ fn add_integers() { value_parameters: None, return_type: Type::Integer, }, - vec![ - ( - Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), - Span(2, 3) - ), - (Instruction::r#return(true), Span(5, 5)) + smallvec![ + Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), + Instruction::r#return(true) ], - vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)], + smallvec![Span(2, 3), Span(5, 5),], + smallvec![Value::integer(1), Value::integer(2)], + smallvec![], vec![] )) ); - assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(3)))); + assert_eq!(run(source), Ok(Some(Value::integer(3)))); } #[test] @@ -212,19 +203,18 @@ fn add_integers_saturate() { value_parameters: None, return_type: Type::Integer, }, - vec![ - ( - Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), - Span(20, 21) - ), - (Instruction::r#return(true), Span(23, 23)) + smallvec![ + Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), + Instruction::r#return(true) ], - vec![ConcreteValue::Integer(i64::MAX), ConcreteValue::Integer(1)], + smallvec![Span(20, 21), Span(23, 23),], + smallvec![Value::integer(i64::MAX), Value::integer(1)], + smallvec![], vec![] )) ); - assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(i64::MAX)))); + assert_eq!(run(source), Ok(Some(Value::integer(i64::MAX)))); } #[test] @@ -240,17 +230,13 @@ fn add_strings() { value_parameters: None, return_type: Type::String, }, - vec![ - ( - Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), - Span(10, 11) - ), - (Instruction::r#return(true), Span(20, 20)) - ], - vec![ - ConcreteValue::string("Hello, "), - ConcreteValue::string("world!") + smallvec![ + Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), + Instruction::r#return(true), ], + smallvec![Span(10, 11), Span(20, 20)], + smallvec![Value::string("Hello, "), Value::string("world!")], + smallvec![], vec![] )) ); @@ -269,17 +255,16 @@ fn add_string_and_character() { value_parameters: None, return_type: Type::String, }, - vec![ - ( - Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), - Span(4, 5) - ), - (Instruction::r#return(true), Span(9, 9)) + smallvec![ + Instruction::add(0, Argument::Constant(0), Argument::Constant(1)), + Instruction::r#return(true), ], - vec![ConcreteValue::string("a"), ConcreteValue::Character('b')], + smallvec![Span(4, 5), Span(9, 9),], + smallvec![Value::string("a"), Value::character('b')], + smallvec![], vec![] )) ); - assert_eq!(run(source), Ok(Some(ConcreteValue::string("ab")))); + assert_eq!(run(source), Ok(Some(Value::string("ab")))); }