Noratrieb/dilaria
1
0
Fork 0
mirror of https://github.com/Noratrieb/dilaria.git synced 2026-01-16 18:35:02 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

test stuff

Browse source
This commit is contained in:
nora 2021-10-31 01:32:56 +02:00
parent f6fcca589e
commit c9b985942b
1 changed files with 72 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

102
src/parse.rs
View file

@ -273,11 +273,13 @@ impl CompilerError for ParseErr<'_> {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use crate::ast::{BinaryOp, BinaryOpKind};
use crate::lex::{Token, TokenType}; use crate::lex::{Token, TokenType};
use crate::parse::Parser; use crate::parse::Parser;
use prelude::*;
mod prelude { mod prelude {
pub(super) use super::{parser, token}; pub(super) use super::{parser, test_literal_bin_op, token};
pub(super) use crate::ast::{Expr, Literal}; pub(super) use crate::ast::{Expr, Literal};
pub(super) use crate::errors::Span; pub(super) use crate::errors::Span;
pub(super) use crate::lex::{Token, TokenType}; pub(super) use crate::lex::{Token, TokenType};
@ -296,79 +298,119 @@ mod test {
} }
} }
fn test_literal_bin_op<F: FnOnce(Vec<Token<'_>>) -> Expr>(
token_type: TokenType,
expected_op_kind: BinaryOpKind,
parser: F,
) {
let tokens = [TokenType::Number(10.0), token_type, TokenType::Number(4.0)]
.map(token)
.into();
let factor = parser(tokens);
assert_eq!(
Expr::BinaryOp(Box::new(BinaryOp {
span: Span::dummy(),
lhs: Expr::Literal(Literal::Number(10.0, Span::dummy())),
rhs: Expr::Literal(Literal::Number(4.0, Span::dummy())),
kind: expected_op_kind
})),
factor
);
}
mod factor { mod factor {
use super::prelude::*; use super::prelude::*;
use crate::ast::{BinaryOp, BinaryOpKind}; use crate::ast::{BinaryOp, BinaryOpKind};
fn parse_factor<'a, T: Into<Vec<Token<'a>>>>(tokens: T) -> Expr { fn parse_factor(tokens: Vec<Token>) -> Expr {
let mut parser = parser(tokens); let mut parser = parser(tokens);
parser.factor().unwrap() parser.factor().unwrap()
} }
fn test_literal_factor(token_type: TokenType, expected_op_kind: BinaryOpKind) {
let tokens = [TokenType::Number(10.0), token_type, TokenType::Number(4.0)].map(token);
let factor = parse_factor(tokens);
assert_eq!(
Expr::BinaryOp(Box::new(BinaryOp {
span: Span::dummy(),
lhs: Expr::Literal(Literal::Number(10.0, Span::dummy())),
rhs: Expr::Literal(Literal::Number(4.0, Span::dummy())),
kind: expected_op_kind
})),
factor
);
}
#[test] #[test]
fn multiply() { fn multiply() {
test_literal_factor(TokenType::Asterisk, BinaryOpKind::Mul); test_literal_bin_op(TokenType::Asterisk, BinaryOpKind::Mul, parse_factor);
} }
#[test] #[test]
fn divide() { fn divide() {
test_literal_factor(TokenType::Slash, BinaryOpKind::Div); test_literal_bin_op(TokenType::Slash, BinaryOpKind::Div, parse_factor);
} }
#[test] #[test]
fn modulo() { fn modulo() {
test_literal_factor(TokenType::Percent, BinaryOpKind::Mod); test_literal_bin_op(TokenType::Percent, BinaryOpKind::Mod, parse_factor);
} }
} }
mod unary { mod unary {
use super::prelude::*; use super::prelude::*;
use crate::ast::{UnaryOp, UnaryOpKind};
fn parse_unary<'a, T: Into<Vec<Token<'a>>>>(tokens: T) -> Expr { fn parse_unary(tokens: Vec<Token>) -> Expr {
let mut parser = parser(tokens); let mut parser = parser(tokens);
parser.primary().unwrap() parser.unary().unwrap()
} }
#[test] #[test]
fn number_literal() { fn number_literal() {
let tokens = [TokenType::Number(10.0)].map(token); let tokens = [TokenType::Number(10.0)].map(token).into();
let unary = parse_unary(tokens); let unary = parse_unary(tokens);
assert_eq!(Expr::Literal(Literal::Number(10.0, Span::dummy())), unary); assert_eq!(Expr::Literal(Literal::Number(10.0, Span::dummy())), unary);
} }
// needs expr support
//
// #[test]
// fn not() {
// let tokens = [TokenType::Not, TokenType::True].map(token).into();
// let unary = parse_unary(tokens);
// assert_eq!(
// Expr::UnaryOp(Box::new(UnaryOp {
// span: Span::dummy(),
// expr: Expr::Literal(Literal::Boolean(true, Span::dummy())),
// kind: UnaryOpKind::Not
// })),
// unary
// );
// }
//
// #[test]
// fn neg() {
// let tokens = [TokenType::Minus, TokenType::Number(10.0)]
// .map(token)
// .into();
// let unary = parse_unary(tokens);
// assert_eq!(
// Expr::UnaryOp(Box::new(UnaryOp {
// span: Span::dummy(),
// expr: Expr::Literal(Literal::Number(10.0, Span::dummy())),
// kind: UnaryOpKind::Neg
// })),
// unary
// );
// }
} }
mod primary { mod primary {
use super::prelude::*; use super::prelude::*;
fn parse_primary<'a, T: Into<Vec<Token<'a>>>>(tokens: T) -> Expr { fn parse_primary(tokens: Vec<Token>) -> Expr {
let mut parser = parser(tokens); let mut parser = parser(tokens);
parser.primary().unwrap() parser.primary().unwrap()
} }
#[test] #[test]
fn string() { fn string() {
let tokens = [TokenType::Number(10.0)].map(token); let tokens = [TokenType::Number(10.0)].map(token).into();
let literal = parse_primary(tokens); let literal = parse_primary(tokens);
assert_eq!(Expr::Literal(Literal::Number(10.0, Span::dummy())), literal); assert_eq!(Expr::Literal(Literal::Number(10.0, Span::dummy())), literal);
} }
#[test] #[test]
fn number() { fn number() {
let tokens = [TokenType::String("uwu".to_string())].map(token); let tokens = [TokenType::String("uwu".to_string())].map(token).into();
let literal = parse_primary(tokens); let literal = parse_primary(tokens);
assert_eq!( assert_eq!(
Expr::Literal(Literal::String("uwu".to_string(), Span::dummy())), Expr::Literal(Literal::String("uwu".to_string(), Span::dummy())),
@ -378,14 +420,14 @@ mod test {
#[test] #[test]
fn empty_object() { fn empty_object() {
let tokens = [TokenType::BraceO, TokenType::BraceC].map(token); let tokens = [TokenType::BraceO, TokenType::BraceC].map(token).into();
let literal = parse_primary(tokens); let literal = parse_primary(tokens);
assert_eq!(Expr::Literal(Literal::Object(Span::dummy())), literal); assert_eq!(Expr::Literal(Literal::Object(Span::dummy())), literal);
} }
#[test] #[test]
fn empty_array() { fn empty_array() {
let tokens = [TokenType::BracketO, TokenType::BracketC].map(token); let tokens = [TokenType::BracketO, TokenType::BracketC].map(token).into();
let literal = parse_primary(tokens); let literal = parse_primary(tokens);
assert_eq!( assert_eq!(
Expr::Literal(Literal::Array(Vec::new(), Span::dummy())), Expr::Literal(Literal::Array(Vec::new(), Span::dummy())),
@ -395,7 +437,7 @@ mod test {
#[test] #[test]
fn r#false() { fn r#false() {
let tokens = [TokenType::False].map(token); let tokens = [TokenType::False].map(token).into();
let literal = parse_primary(tokens); let literal = parse_primary(tokens);
assert_eq!( assert_eq!(
Expr::Literal(Literal::Boolean(false, Span::dummy())), Expr::Literal(Literal::Boolean(false, Span::dummy())),
@ -405,7 +447,7 @@ mod test {
#[test] #[test]
fn r#true() { fn r#true() {
let tokens = [TokenType::True].map(token); let tokens = [TokenType::True].map(token).into();
let literal = parse_primary(tokens); let literal = parse_primary(tokens);
assert_eq!( assert_eq!(
Expr::Literal(Literal::Boolean(true, Span::dummy())), Expr::Literal(Literal::Boolean(true, Span::dummy())),
@ -415,7 +457,7 @@ mod test {
#[test] #[test]
fn null() { fn null() {
let tokens = [TokenType::Null].map(token); let tokens = [TokenType::Null].map(token).into();
let literal = parse_primary(tokens); let literal = parse_primary(tokens);
assert_eq!(Expr::Literal(Literal::Null(Span::dummy())), literal); assert_eq!(Expr::Literal(Literal::Null(Span::dummy())), literal);
} }