jeff/dust
1
0
Fork 0
Code Issues

Add math tests

Browse Source
This commit is contained in:
Jeff 2024-12-03 14:27:48 -05:00
parent 544edaf5f4
commit 827a3df815
17 changed files with 260 additions and 542 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

409
dust-lang/tests/control_flow/comparison_expressions.rs
View File

@ -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
})
);
}

34
dust-lang/tests/control_flow/logic_expressions.rs
View File

@ -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))),);
}

33
dust-lang/tests/divide.rs
View File

@ -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))));
}

0
dust-lang/tests/add.rs → dust-lang/tests/math_add.rs
View File

0
dust-lang/tests/add_assign.rs → dust-lang/tests/math_add_assign.rs
View File

0
dust-lang/tests/add_type_errors.rs → dust-lang/tests/math_add_type_errors.rs
View File

65
dust-lang/tests/math_divide.rs Normal file
View File

@ -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))));
}

0
dust-lang/tests/divide_assign.rs → dust-lang/tests/math_divide_assign.rs
View File

65
dust-lang/tests/math_modulo.rs Normal file
View File

@ -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))));
}

0
dust-lang/tests/modulo.rs → dust-lang/tests/math_modulo_assign.rs
View File

65
dust-lang/tests/math_multiply.rs Normal file
View File

@ -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))));
}

0
dust-lang/tests/multiply_assign.rs → dust-lang/tests/math_multiply_assign.rs
View File

65
dust-lang/tests/math_subtract.rs Normal file
View File

@ -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))));
}

0
dust-lang/tests/subtract_assign.rs → dust-lang/tests/math_subtract_assign.rs
View File

0
dust-lang/tests/modulo_assign.rs
View File

33
dust-lang/tests/multiply.rs
View File

@ -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))));
}

33
dust-lang/tests/subtract.rs
View File

@ -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))));
}