From f25f658cd37c967081fe598df874141d867c942e Mon Sep 17 00:00:00 2001 From: Jeff Date: Tue, 3 Dec 2024 16:49:36 -0500 Subject: [PATCH] Add tests --- dust-lang/tests/math_multiply_errors.rs | 229 ++++++++++++++++++++++++ dust-lang/tests/math_subtract_errors.rs | 229 ++++++++++++++++++++++++ 2 files changed, 458 insertions(+) create mode 100644 dust-lang/tests/math_multiply_errors.rs create mode 100644 dust-lang/tests/math_subtract_errors.rs diff --git a/dust-lang/tests/math_multiply_errors.rs b/dust-lang/tests/math_multiply_errors.rs new file mode 100644 index 0000000..bca4f55 --- /dev/null +++ b/dust-lang/tests/math_multiply_errors.rs @@ -0,0 +1,229 @@ +use dust_lang::*; + +#[test] +fn multiply_boolean_left() { + let source = "true * 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyType { + argument_type: Type::Boolean, + position: Span(0, 4) + }, + source, + }) + ); +} + +#[test] +fn multiply_boolean_right() { + let source = "1 * true"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyType { + argument_type: Type::Boolean, + position: Span(4, 8) + }, + source, + }) + ); +} + +#[test] +fn multiply_character_left() { + let source = "'a' * 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyType { + argument_type: Type::Character, + position: Span(0, 3) + }, + source, + }) + ); +} + +#[test] +fn multiply_character_right() { + let source = "1 * 'a'"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyType { + argument_type: Type::Character, + position: Span(4, 7) + }, + source, + }) + ); +} + +#[test] +fn multiply_float_and_character() { + let source = "1.0 * 'a'"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyType { + argument_type: Type::Character, + position: Span(6, 9) + }, + source, + }) + ); +} + +#[test] +fn multiply_float_and_integer() { + let source = "1.0 * 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyArguments { + left_type: Type::Float, + right_type: Type::Integer, + position: Span(0, 7) + }, + source, + }) + ); +} + +#[test] +fn multiply_function_left() { + let source = "fn(){} * 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyType { + argument_type: Type::Function(FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::None) + }), + position: Span(0, 6) + }, + source, + }) + ); +} + +#[test] +fn multiply_function_right() { + let source = "1 * fn(){}"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyType { + argument_type: Type::Function(FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::None) + }), + position: Span(4, 10) + }, + source, + }) + ); +} + +#[test] +fn multiply_integer_and_float() { + let source = "1 * 1.0"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyArguments { + left_type: Type::Integer, + right_type: Type::Float, + position: Span(0, 7) + }, + source, + }) + ); +} + +#[test] +fn multiply_list_left() { + let source = "[1, 2] * 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyType { + argument_type: Type::List(Box::new(Type::Integer)), + position: Span(0, 6) + }, + source, + }) + ); +} + +#[test] +fn multiply_list_right() { + let source = "1 * [1, 2]"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyType { + argument_type: Type::List(Box::new(Type::Integer)), + position: Span(4, 10) + }, + source, + }) + ); +} + +// #[test] +// fn add_range_left() { +// todo!("Add ranges") +// } + +// #[test] +// fn add_range_right() { +// todo!("Add ranges") +// } + +#[test] +fn multiply_string_left() { + let source = "\"hello\" * 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyType { + argument_type: Type::String, + position: Span(0, 7) + }, + source, + }) + ); +} + +#[test] +fn multiply_string_right() { + let source = "1 * \"hello\""; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotMultiplyType { + argument_type: Type::String, + position: Span(4, 11) + }, + source, + }) + ); +} diff --git a/dust-lang/tests/math_subtract_errors.rs b/dust-lang/tests/math_subtract_errors.rs new file mode 100644 index 0000000..e88608a --- /dev/null +++ b/dust-lang/tests/math_subtract_errors.rs @@ -0,0 +1,229 @@ +use dust_lang::*; + +#[test] +fn subtract_boolean_left() { + let source = "true - 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractType { + argument_type: Type::Boolean, + position: Span(0, 4) + }, + source, + }) + ); +} + +#[test] +fn subtract_boolean_right() { + let source = "1 - true"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractType { + argument_type: Type::Boolean, + position: Span(4, 8) + }, + source, + }) + ); +} + +#[test] +fn subtract_character_left() { + let source = "'a' - 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractType { + argument_type: Type::Character, + position: Span(0, 3) + }, + source, + }) + ); +} + +#[test] +fn subtract_character_right() { + let source = "1 - 'a'"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractType { + argument_type: Type::Character, + position: Span(4, 7) + }, + source, + }) + ); +} + +#[test] +fn subtract_float_and_character() { + let source = "1.0 - 'a'"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractType { + argument_type: Type::Character, + position: Span(6, 9) + }, + source, + }) + ); +} + +#[test] +fn subtract_float_and_integer() { + let source = "1.0 - 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractArguments { + left_type: Type::Float, + right_type: Type::Integer, + position: Span(0, 7) + }, + source, + }) + ); +} + +#[test] +fn subtract_function_left() { + let source = "fn(){} - 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractType { + argument_type: Type::Function(FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::None) + }), + position: Span(0, 6) + }, + source, + }) + ); +} + +#[test] +fn subtract_function_right() { + let source = "1 - fn(){}"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractType { + argument_type: Type::Function(FunctionType { + type_parameters: None, + value_parameters: None, + return_type: Box::new(Type::None) + }), + position: Span(4, 10) + }, + source, + }) + ); +} + +#[test] +fn subtract_integer_and_float() { + let source = "1 - 1.0"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractArguments { + left_type: Type::Integer, + right_type: Type::Float, + position: Span(0, 7) + }, + source, + }) + ); +} + +#[test] +fn subtract_list_left() { + let source = "[1, 2] - 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractType { + argument_type: Type::List(Box::new(Type::Integer)), + position: Span(0, 6) + }, + source, + }) + ); +} + +#[test] +fn subtract_list_right() { + let source = "1 - [1, 2]"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractType { + argument_type: Type::List(Box::new(Type::Integer)), + position: Span(4, 10) + }, + source, + }) + ); +} + +// #[test] +// fn add_range_left() { +// todo!("Add ranges") +// } + +// #[test] +// fn add_range_right() { +// todo!("Add ranges") +// } + +#[test] +fn subtract_string_left() { + let source = "\"hello\" - 1"; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractType { + argument_type: Type::String, + position: Span(0, 7) + }, + source, + }) + ); +} + +#[test] +fn subtract_string_right() { + let source = "1 - \"hello\""; + + assert_eq!( + compile(source), + Err(DustError::Compile { + error: CompileError::CannotSubtractType { + argument_type: Type::String, + position: Span(4, 11) + }, + source, + }) + ); +}