From 8fd164bda2f5c1626ef995837bafb804e135e2e7 Mon Sep 17 00:00:00 2001 From: pca006132 Date: Thu, 31 Dec 2020 11:31:42 +0800 Subject: [PATCH] added expression tests --- nac3core/src/expression.rs | 638 +++++++++++++++++++++++++++++++++++++ 1 file changed, 638 insertions(+) diff --git a/nac3core/src/expression.rs b/nac3core/src/expression.rs index 4192fa4c..1e24bbdb 100644 --- a/nac3core/src/expression.rs +++ b/nac3core/src/expression.rs @@ -383,3 +383,641 @@ fn infer_list_comprehension( } } +#[cfg(test)] +mod test { + use super::*; + use crate::typedef::*; + use rustpython_parser::parser::parse_expression; + + #[test] + fn test_constants() { + let ctx = basic_ctx(); + let sym_table = HashMap::new(); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("123").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("2147483647").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("2147483648").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT64_TYPE).into()); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("9223372036854775807").unwrap(), + ); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT64_TYPE).into()); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("9223372036854775808").unwrap(), + ); + assert_eq!(result, Err("integer out of range".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("123.456").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(FLOAT_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("True").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(BOOL_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("False").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(BOOL_TYPE).into()); + } + + #[test] + fn test_identifier() { + let ctx = basic_ctx(); + let mut sym_table = HashMap::new(); + sym_table.insert("abc", Rc::new(PrimitiveType(INT32_TYPE))); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("abc").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("ab").unwrap()); + assert_eq!(result, Err("unbounded variable".into())); + } + + #[test] + fn test_list() { + let mut ctx = basic_ctx(); + ctx.add_fn( + "foo", + FnDef { + args: vec![], + result: None, + }, + ); + let mut sym_table = HashMap::new(); + sym_table.insert("abc", Rc::new(PrimitiveType(INT32_TYPE))); + // def is reserved... + sym_table.insert("efg", Rc::new(PrimitiveType(INT32_TYPE))); + sym_table.insert("xyz", Rc::new(PrimitiveType(FLOAT_TYPE))); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("[]").unwrap()); + assert_eq!( + result.unwrap().unwrap(), + ParametricType(LIST_TYPE, vec![BotType.into()]).into() + ); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("[abc]").unwrap()); + assert_eq!( + result.unwrap().unwrap(), + ParametricType(LIST_TYPE, vec![PrimitiveType(INT32_TYPE).into()]).into() + ); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("[abc, efg]").unwrap()); + assert_eq!( + result.unwrap().unwrap(), + ParametricType(LIST_TYPE, vec![PrimitiveType(INT32_TYPE).into()]).into() + ); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[abc, efg, xyz]").unwrap(), + ); + assert_eq!(result, Err("inhomogeneous list is not allowed".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("[foo()]").unwrap()); + assert_eq!(result, Err("list elements must have some type".into())); + } + + #[test] + fn test_tuple() { + let mut ctx = basic_ctx(); + ctx.add_fn( + "foo", + FnDef { + args: vec![], + result: None, + }, + ); + let mut sym_table = HashMap::new(); + sym_table.insert("abc", Rc::new(PrimitiveType(INT32_TYPE))); + sym_table.insert("efg", Rc::new(PrimitiveType(FLOAT_TYPE))); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("(abc, efg)").unwrap()); + assert_eq!( + result.unwrap().unwrap(), + ParametricType( + TUPLE_TYPE, + vec![ + PrimitiveType(INT32_TYPE).into(), + PrimitiveType(FLOAT_TYPE).into() + ] + ) + .into() + ); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("(abc, efg, foo())").unwrap(), + ); + assert_eq!(result, Err("tuple elements must have some type".into())); + } + + #[test] + fn test_attribute() { + let mut ctx = basic_ctx(); + ctx.add_fn( + "none", + FnDef { + args: vec![], + result: None, + }, + ); + + let foo = ctx.add_class(ClassDef { + base: TypeDef { + name: "Foo", + fields: HashMap::new(), + methods: HashMap::new(), + }, + parents: vec![], + }); + let foo_def = ctx.get_class_mut(foo); + foo_def + .base + .fields + .insert("a", PrimitiveType(INT32_TYPE).into()); + foo_def.base.fields.insert("b", ClassType(foo).into()); + foo_def + .base + .fields + .insert("c", PrimitiveType(INT32_TYPE).into()); + + let bar = ctx.add_class(ClassDef { + base: TypeDef { + name: "Bar", + fields: HashMap::new(), + methods: HashMap::new(), + }, + parents: vec![], + }); + let bar_def = ctx.get_class_mut(bar); + bar_def + .base + .fields + .insert("a", PrimitiveType(INT32_TYPE).into()); + bar_def.base.fields.insert("b", ClassType(bar).into()); + bar_def + .base + .fields + .insert("c", PrimitiveType(FLOAT_TYPE).into()); + + let v0 = ctx.add_variable(VarDef { + name: "v0", + bound: vec![], + }); + + let v1 = ctx.add_variable(VarDef { + name: "v1", + bound: vec![ClassType(foo).into(), ClassType(bar).into()], + }); + + let mut sym_table = HashMap::new(); + sym_table.insert("foo", Rc::new(ClassType(foo))); + sym_table.insert("bar", Rc::new(ClassType(bar))); + sym_table.insert("foobar", Rc::new(VirtualClassType(foo))); + sym_table.insert("v0", Rc::new(TypeVariable(v0))); + sym_table.insert("v1", Rc::new(TypeVariable(v1))); + sym_table.insert("bot", Rc::new(BotType)); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("foo.a").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("foo.d").unwrap()); + assert_eq!(result, Err("no such field".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("foobar.a").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("v0.a").unwrap()); + assert_eq!(result, Err("no fields on unbounded type variable".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("v1.a").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into()); + + // shall we support this? + let result = infer_expr(&ctx, &sym_table, &parse_expression("v1.b").unwrap()); + assert_eq!( + result, + Err("unknown field (type mismatch between variants)".into()) + ); + // assert_eq!(result.unwrap().unwrap(), TypeVariable(v1).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("v1.c").unwrap()); + assert_eq!( + result, + Err("unknown field (type mismatch between variants)".into()) + ); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("v1.d").unwrap()); + assert_eq!(result, Err("unknown field".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("none().a").unwrap()); + assert_eq!(result, Err("no value".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("bot.a").unwrap()); + assert_eq!(result, Err("this object has no fields".into())); + } + + #[test] + fn test_bool_ops() { + let mut ctx = basic_ctx(); + ctx.add_fn( + "none", + FnDef { + args: vec![], + result: None, + }, + ); + let sym_table = HashMap::new(); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("True and False").unwrap(), + ); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(BOOL_TYPE).into()); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("True and none()").unwrap(), + ); + assert_eq!(result, Err("no value".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("True and 123").unwrap()); + assert_eq!(result, Err("bool operands must be bool".into())); + } + + #[test] + fn test_bin_ops() { + let mut ctx = basic_ctx(); + let v0 = ctx.add_variable(VarDef { + name: "v0", + bound: vec![ + PrimitiveType(INT32_TYPE).into(), + PrimitiveType(INT64_TYPE).into(), + ], + }); + let mut sym_table = HashMap::new(); + sym_table.insert("a", TypeVariable(v0).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("1 + 2 + 3").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("a + a + a").unwrap()); + assert_eq!(result.unwrap().unwrap(), TypeVariable(v0).into()); + } + + #[test] + fn test_unary_ops() { + let mut ctx = basic_ctx(); + let v0 = ctx.add_variable(VarDef { + name: "v0", + bound: vec![ + PrimitiveType(INT32_TYPE).into(), + PrimitiveType(INT64_TYPE).into(), + ], + }); + let mut sym_table = HashMap::new(); + sym_table.insert("a", TypeVariable(v0).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("-(123)").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("-a").unwrap()); + assert_eq!(result.unwrap().unwrap(), TypeVariable(v0).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("not True").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(BOOL_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("not (1)").unwrap()); + assert_eq!(result, Err("logical not must be applied to bool".into())); + } + + #[test] + fn test_compare() { + let mut ctx = basic_ctx(); + let v0 = ctx.add_variable(VarDef { + name: "v0", + bound: vec![ + PrimitiveType(INT32_TYPE).into(), + PrimitiveType(INT64_TYPE).into(), + ], + }); + let mut sym_table = HashMap::new(); + sym_table.insert("a", TypeVariable(v0).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("a == a == a").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(BOOL_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("a == a == 1").unwrap()); + assert_eq!(result, Err("not equal".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("True > False").unwrap()); + assert_eq!(result, Err("no such function".into())); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("True in False").unwrap(), + ); + assert_eq!(result, Err("unsupported comparison".into())); + } + + #[test] + fn test_call() { + let mut ctx = basic_ctx(); + ctx.add_fn( + "none", + FnDef { + args: vec![], + result: None, + }, + ); + + let foo = ctx.add_class(ClassDef { + base: TypeDef { + name: "Foo", + fields: HashMap::new(), + methods: HashMap::new(), + }, + parents: vec![], + }); + let foo_def = ctx.get_class_mut(foo); + foo_def.base.methods.insert( + "a", + FnDef { + args: vec![], + result: Some(Rc::new(ClassType(foo))), + }, + ); + + let bar = ctx.add_class(ClassDef { + base: TypeDef { + name: "Bar", + fields: HashMap::new(), + methods: HashMap::new(), + }, + parents: vec![], + }); + let bar_def = ctx.get_class_mut(bar); + bar_def.base.methods.insert( + "a", + FnDef { + args: vec![], + result: Some(Rc::new(ClassType(bar))), + }, + ); + + let v0 = ctx.add_variable(VarDef { + name: "v0", + bound: vec![], + }); + let v1 = ctx.add_variable(VarDef { + name: "v1", + bound: vec![ClassType(foo).into(), ClassType(bar).into()], + }); + let v2 = ctx.add_variable(VarDef { + name: "v2", + bound: vec![ + ClassType(foo).into(), + ClassType(bar).into(), + PrimitiveType(INT32_TYPE).into(), + ], + }); + let mut sym_table = HashMap::new(); + sym_table.insert("foo", Rc::new(ClassType(foo))); + sym_table.insert("bar", Rc::new(ClassType(bar))); + sym_table.insert("foobar", Rc::new(VirtualClassType(foo))); + sym_table.insert("v0", Rc::new(TypeVariable(v0))); + sym_table.insert("v1", Rc::new(TypeVariable(v1))); + sym_table.insert("v2", Rc::new(TypeVariable(v2))); + sym_table.insert("bot", Rc::new(BotType)); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("foo.a()").unwrap()); + assert_eq!(result.unwrap().unwrap(), ClassType(foo).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("v1.a()").unwrap()); + assert_eq!(result.unwrap().unwrap(), TypeVariable(v1).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("foobar.a()").unwrap()); + assert_eq!(result.unwrap().unwrap(), ClassType(foo).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("none().a()").unwrap()); + assert_eq!(result, Err("no value".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("bot.a()").unwrap()); + assert_eq!(result, Err("not supported".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("[][0].a()").unwrap()); + assert_eq!(result, Err("not supported".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("v0.a()").unwrap()); + assert_eq!(result, Err("unbounded type var".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("v2.a()").unwrap()); + assert_eq!(result, Err("no such function".into())); + } + + #[test] + fn infer_subscript() { + let mut ctx = basic_ctx(); + ctx.add_fn( + "none", + FnDef { + args: vec![], + result: None, + }, + ); + let sym_table = HashMap::new(); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("[1, 2, 3][0]").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into()); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("[[1]][0][0]").unwrap()); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into()); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[1, 2, 3][1:2]").unwrap(), + ); + assert_eq!( + result.unwrap().unwrap(), + ParametricType(LIST_TYPE, vec![PrimitiveType(INT32_TYPE).into()]).into() + ); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[1, 2, 3][1:2:2]").unwrap(), + ); + assert_eq!( + result.unwrap().unwrap(), + ParametricType(LIST_TYPE, vec![PrimitiveType(INT32_TYPE).into()]).into() + ); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[1, 2, 3][1:1.2]").unwrap(), + ); + assert_eq!(result, Err("slice must be int32 type".into())); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[1, 2, 3][1:none()]").unwrap(), + ); + assert_eq!(result, Err("slice must have type".into())); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[1, 2, 3][1.2]").unwrap(), + ); + assert_eq!(result, Err("index must be either slice or int32".into())); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[1, 2, 3][none()]").unwrap(), + ); + assert_eq!(result, Err("no value".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("none()[1.2]").unwrap()); + assert_eq!(result, Err("no value".into())); + + let result = infer_expr(&ctx, &sym_table, &parse_expression("123[1]").unwrap()); + assert_eq!( + result, + Err("subscript is not supported for types other than list".into()) + ); + } + + #[test] + fn test_if_expr() { + let mut ctx = basic_ctx(); + ctx.add_fn( + "none", + FnDef { + args: vec![], + result: None, + }, + ); + let sym_table = HashMap::new(); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("1 if True else 0").unwrap(), + ); + assert_eq!(result.unwrap().unwrap(), PrimitiveType(INT32_TYPE).into()); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("none() if True else none()").unwrap(), + ); + assert_eq!(result.unwrap(), None); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("none() if 1 else none()").unwrap(), + ); + assert_eq!(result, Err("test should be bool".into())); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("1 if True else none()").unwrap(), + ); + assert_eq!(result, Err("divergent type".into())); + } + + #[test] + fn test_list_comp() { + let mut ctx = basic_ctx(); + ctx.add_fn( + "none", + FnDef { + args: vec![], + result: None, + }, + ); + let int32 = Rc::new(PrimitiveType(INT32_TYPE)); + let mut sym_table = HashMap::new(); + sym_table.insert("z", int32.clone()); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[x for x in [(1, 2), (2, 3), (3, 4)]][0]").unwrap(), + ); + assert_eq!( + result.unwrap().unwrap(), + ParametricType(TUPLE_TYPE, vec![int32.clone(), int32.clone()]).into() + ); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[x for (x, y) in [(1, 2), (2, 3), (3, 4)]][0]").unwrap(), + ); + assert_eq!(result.unwrap().unwrap(), int32.clone()); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[x for (x, y) in [(1, 2), (2, 3), (3, 4)] if x > 0][0]").unwrap(), + ); + assert_eq!(result.unwrap().unwrap(), int32.clone()); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[x for (x, y) in [(1, 2), (2, 3), (3, 4)] if x][0]").unwrap(), + ); + assert_eq!(result, Err("test must be bool".into())); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[y for x in []][0]").unwrap(), + ); + assert_eq!(result, Err("unbounded variable".into())); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[none() for x in []][0]").unwrap(), + ); + assert_eq!(result, Err("no value".into())); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[z for z in []][0]").unwrap(), + ); + assert_eq!(result, Err("duplicated naming".into())); + + let result = infer_expr( + &ctx, + &sym_table, + &parse_expression("[x for x in [] for y in []]").unwrap(), + ); + assert_eq!( + result, + Err("only 1 generator statement is supported".into()) + ); + } +}