From cc93d8e34550eb13a1863f22688140a454a1aa6f Mon Sep 17 00:00:00 2001 From: Jeff Date: Tue, 11 Feb 2025 03:54:56 -0500 Subject: [PATCH] Add tests for the "and" and "or" operators --- dust-lang/Cargo.toml | 8 +++ dust-lang/tests/logic/and.rs | 111 +++++++++++++++++++++++++++++++++++ dust-lang/tests/logic/or.rs | 111 +++++++++++++++++++++++++++++++++++ 3 files changed, 230 insertions(+) create mode 100644 dust-lang/tests/logic/and.rs create mode 100644 dust-lang/tests/logic/or.rs diff --git a/dust-lang/Cargo.toml b/dust-lang/Cargo.toml index a83789b..df75bf8 100644 --- a/dust-lang/Cargo.toml +++ b/dust-lang/Cargo.toml @@ -82,3 +82,11 @@ path = "tests/comparison/not_equal.rs" [[test]] name = "greater_equal" path = "tests/comparison/greater_equal.rs" + +[[test]] +name = "and" +path = "tests/logic/and.rs" + +[[test]] +name = "or" +path = "tests/logic/or.rs" diff --git a/dust-lang/tests/logic/and.rs b/dust-lang/tests/logic/and.rs new file mode 100644 index 0000000..f9dd71b --- /dev/null +++ b/dust-lang/tests/logic/and.rs @@ -0,0 +1,111 @@ +use dust_lang::{ + Chunk, FunctionType, Instruction, Span, Type, Value, compile, instruction::TypeCode, run, +}; + +#[test] +fn true_and_true() { + let source = "true && true"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Boolean), + instructions: vec![ + Instruction::load_encoded(0, true as u8, TypeCode::BOOLEAN, false), + Instruction::test(0, true), + Instruction::jump(1, true), + Instruction::load_encoded(0, true as u8, TypeCode::BOOLEAN, false), + Instruction::r#return(true, 0, TypeCode::BOOLEAN), + ], + positions: vec![ + Span(0, 4), + Span(5, 7), + Span(5, 7), + Span(8, 12), + Span(12, 12), + ], + ..Chunk::default() + }; + let return_value = Some(Value::boolean(true)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} + +#[test] +fn true_and_false() { + let source = "true && false"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Boolean), + instructions: vec![ + Instruction::load_encoded(0, true as u8, TypeCode::BOOLEAN, false), + Instruction::test(0, true), + Instruction::jump(1, true), + Instruction::load_encoded(0, false as u8, TypeCode::BOOLEAN, false), + Instruction::r#return(true, 0, TypeCode::BOOLEAN), + ], + positions: vec![ + Span(0, 4), + Span(5, 7), + Span(5, 7), + Span(8, 13), + Span(13, 13), + ], + ..Chunk::default() + }; + let return_value = Some(Value::boolean(false)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} + +#[test] +fn false_and_true() { + let source = "false && true"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Boolean), + instructions: vec![ + Instruction::load_encoded(0, false as u8, TypeCode::BOOLEAN, false), + Instruction::test(0, true), + Instruction::jump(1, true), + Instruction::load_encoded(0, true as u8, TypeCode::BOOLEAN, false), + Instruction::r#return(true, 0, TypeCode::BOOLEAN), + ], + positions: vec![ + Span(0, 5), + Span(6, 8), + Span(6, 8), + Span(9, 13), + Span(13, 13), + ], + ..Chunk::default() + }; + let return_value = Some(Value::boolean(false)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} + +#[test] +fn false_and_false() { + let source = "false && false"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Boolean), + instructions: vec![ + Instruction::load_encoded(0, false as u8, TypeCode::BOOLEAN, false), + Instruction::test(0, true), + Instruction::jump(1, true), + Instruction::load_encoded(0, false as u8, TypeCode::BOOLEAN, false), + Instruction::r#return(true, 0, TypeCode::BOOLEAN), + ], + positions: vec![ + Span(0, 5), + Span(6, 8), + Span(6, 8), + Span(9, 14), + Span(14, 14), + ], + ..Chunk::default() + }; + let return_value = Some(Value::boolean(false)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} diff --git a/dust-lang/tests/logic/or.rs b/dust-lang/tests/logic/or.rs new file mode 100644 index 0000000..4f6553a --- /dev/null +++ b/dust-lang/tests/logic/or.rs @@ -0,0 +1,111 @@ +use dust_lang::{ + Chunk, FunctionType, Instruction, Span, Type, Value, compile, instruction::TypeCode, run, +}; + +#[test] +fn true_or_true() { + let source = "true || true"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Boolean), + instructions: vec![ + Instruction::load_encoded(0, true as u8, TypeCode::BOOLEAN, false), + Instruction::test(0, false), + Instruction::jump(1, true), + Instruction::load_encoded(0, true as u8, TypeCode::BOOLEAN, false), + Instruction::r#return(true, 0, TypeCode::BOOLEAN), + ], + positions: vec![ + Span(0, 4), + Span(5, 7), + Span(5, 7), + Span(8, 12), + Span(12, 12), + ], + ..Chunk::default() + }; + let return_value = Some(Value::boolean(true)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} + +#[test] +fn true_or_false() { + let source = "true || false"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Boolean), + instructions: vec![ + Instruction::load_encoded(0, true as u8, TypeCode::BOOLEAN, false), + Instruction::test(0, false), + Instruction::jump(1, true), + Instruction::load_encoded(0, false as u8, TypeCode::BOOLEAN, false), + Instruction::r#return(true, 0, TypeCode::BOOLEAN), + ], + positions: vec![ + Span(0, 4), + Span(5, 7), + Span(5, 7), + Span(8, 13), + Span(13, 13), + ], + ..Chunk::default() + }; + let return_value = Some(Value::boolean(true)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} + +#[test] +fn false_or_true() { + let source = "false || true"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Boolean), + instructions: vec![ + Instruction::load_encoded(0, false as u8, TypeCode::BOOLEAN, false), + Instruction::test(0, false), + Instruction::jump(1, true), + Instruction::load_encoded(0, true as u8, TypeCode::BOOLEAN, false), + Instruction::r#return(true, 0, TypeCode::BOOLEAN), + ], + positions: vec![ + Span(0, 5), + Span(6, 8), + Span(6, 8), + Span(9, 13), + Span(13, 13), + ], + ..Chunk::default() + }; + let return_value = Some(Value::boolean(true)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} + +#[test] +fn false_or_false() { + let source = "false || false"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Boolean), + instructions: vec![ + Instruction::load_encoded(0, false as u8, TypeCode::BOOLEAN, false), + Instruction::test(0, false), + Instruction::jump(1, true), + Instruction::load_encoded(0, false as u8, TypeCode::BOOLEAN, false), + Instruction::r#return(true, 0, TypeCode::BOOLEAN), + ], + positions: vec![ + Span(0, 5), + Span(6, 8), + Span(6, 8), + Span(9, 14), + Span(14, 14), + ], + ..Chunk::default() + }; + let return_value = Some(Value::boolean(false)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +}