d849deb | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

d849deb — Peter John 2026-11-01T23:07:45+05:30

test: dedupe core/cli Rust tests (144 -> 106), table-driven formatter/loader cases

Files changed (5) hide show

plum-cli/tests/test_scope_test.rs +0 -10
plum-core/tests/formatter_test.rs +17 -41
plum-core/tests/loader_test.rs +13 -33
plum-core/tests/parser_test.rs +1 -199
plum-core/tests/unions_test.rs +0 -13

plum-cli/tests/test_scope_test.rs CHANGED Viewed

@@ -30,16 +30,6 @@ fn scratch(name: &str) -> std::path::PathBuf {
 const TWO: &str = "import std/Str\nimport std/Int\n\ntest \"one\"\n  assert 1 == 1\n\ntest \"two\"\n  assert 2 == 2\n";
-#[test]
-fn fileRunsOnlyItsOwnTests() {
-    let dir = scratch("file");
-    let f = dir.join("two.plum");
-    std::fs::write(&f, TWO).unwrap();
-    let (out, ok) = runPlum(&[f.to_str().unwrap()]);
-    assert!(ok, "{out}");
-    assert!(out.contains("2 passed, 0 failed"), "{out}");
-}
 #[test]
 fn directoryRunsSumOfOwnTests() {
     let dir = scratch("dir");

plum-core/tests/formatter_test.rs CHANGED Viewed

@@ -1,21 +1,6 @@
 #![allow(non_snake_case)]
 use plum_core::formatSource;
-#[test]
-fn formatsSimpleFunction() {
-    let input = "fun main() =\n  x = 1\n";
-    let result = formatSource(input).expect("formatSource should succeed");
-    assert!(result.contains("main()"));
-    assert!(result.contains("x ="));
-}
-#[test]
-fn formatsBinaryOperatorSpacing() {
-    let input = "fun add(a: Int, b: Int) -> Int =\n  a+b\n";
-    let result = formatSource(input).expect("formatSource should succeed");
-    assert!(result.contains("a + b"));
-}
 #[test]
 fn rejectsSyntaxError() {
     let input = "@@@@invalid@@@@\n";
@@ -23,14 +8,6 @@ fn rejectsSyntaxError() {
     assert!(result.is_err());
 }
-#[test]
-fn idempotentOnAlreadyFormatted() {
-    let input = "fun main() =\n  x = 1 + 2\n";
-    let first = formatSource(input).expect("first pass");
-    let second = formatSource(&first).expect("second pass");
-    assert_eq!(first, second, "formatting should be idempotent");
-}
 /// Regression test for a real bug: Topiary inserts NO whitespace between
 /// adjacent leaves unless a query says to, so keywords with no explicit
 /// spacing rule glue to the next token ("module" + "test" -> "moduletest").
@@ -266,29 +243,28 @@ fn formatsZigStyleErrors() {
     assert_eq!(formatSource(&h).expect("second"), h, "idempotent");
 }
-fn assertFormatStable(input: &str) {
-    let once = formatSource(input).expect("first pass");
-    assert_eq!(once, input);
-    let twice = formatSource(&once).expect("second pass");
-    assert_eq!(twice, once);
-}
 #[test]
-fn formatStructWithBody() {
+fn alreadyFormattedSourceIsUnchanged() {
-    assertFormatStable(
+    for input in [
+        "fun main() =\n  x = 1 + 2\n",
         "struct Vec2(x: Float, y: Float) =\n  ZERO = Vec2(x: 0.0, y: 0.0)\n\n  fun len(self) -> Float =\n    self.x\n",
+        "struct Vec2(x: Float, y: Float)\n\nfun f() -> Int =\n  1\n",
+        "record Pair[K, V](key: K, val: V)\n",
+        "record Pair[K, V](key: K, val: V) =\n  fun first(self) -> K =\n    self.key\n",
-    );
+    ] {
+        let once = formatSource(input).expect("first pass");
+        assert_eq!(once, input);
+        let twice = formatSource(&once).expect("second pass");
+        assert_eq!(twice, once);
-}
+    }
-#[test]
-fn formatStructNoBody() {
-    assertFormatStable("struct Vec2(x: Float, y: Float)\n\nfun f() -> Int =\n  1\n");
 }
 #[test]
-fn formatRecordGeneric() {
+fn spacesOperatorsAndSimpleFunctions() {
+    let r = formatSource("fun add(a: Int, b: Int) -> Int =\n  a+b\n").expect("format");
-    assertFormatStable("record Pair[K, V](key: K, val: V)\n");
+    assert!(r.contains("a + b"), "{r}");
+    let r = formatSource("fun main() =\n  x = 1\n").expect("format");
-    assertFormatStable("record Pair[K, V](key: K, val: V) =\n  fun first(self) -> K =\n    self.key\n");
+    assert!(r.contains("main()") && r.contains("x ="), "{r}");
 }
 #[test]

plum-core/tests/loader_test.rs CHANGED Viewed

@@ -252,21 +252,19 @@ fun main(u: Unit) -> Unit =
 }
 #[test]
-fn double_question_rejected() {
+fn removedSyntaxIsAParseError() {
+    for src in [
+        "fun f(u: Unit) -> Unit??\n  u\n",
+        "fun f(u: Unit) -> Unit? ! [X] =\n  u\n",
+        "PI = 3\n",
+        "extend Foo =\n  fun f() -> Unit =\n    todo\n",
+    ] {
-    let dir = TempDir::new().unwrap();
+        let dir = TempDir::new().unwrap();
-    let entry = dir.path().join("main.plum");
+        let entry = dir.path().join("main.plum");
-    fs::write(&entry, "fun f(u: Unit) -> Unit??\n  u\n").unwrap();
+        fs::write(&entry, src).unwrap();
-    let err = loadAndMerge(&entry, dir.path()).unwrap_err();
+        let err = loadAndMerge(&entry, dir.path()).unwrap_err();
-    assert!(err.contains("parse error"), "{err}");
+        assert!(err.contains("parse error"), "{src}: {err}");
-}
+    }
-#[test]
-fn nullable_bang_rejected() {
-    let dir = TempDir::new().unwrap();
-    let entry = dir.path().join("main.plum");
-    fs::write(&entry, "fun f(u: Unit) -> Unit? ! [X] =\n  u\n").unwrap();
-    let err = loadAndMerge(&entry, dir.path()).unwrap_err();
-    assert!(err.contains("parse error"), "{err}");
 }
 #[test]
@@ -304,24 +302,6 @@ fn assoc_const_names_are_per_type_across_modules() {
     assert!(names.contains(&"Alpha.X".to_string()) && names.contains(&"Beta.X".to_string()), "{names:?}");
 }
-#[test]
-fn toplevel_const_removed() {
-    let dir = TempDir::new().unwrap();
-    let entry = dir.path().join("main.plum");
-    fs::write(&entry, "PI = 3\n").unwrap();
-    let err = loadAndMerge(&entry, dir.path()).unwrap_err();
-    assert!(err.contains("parse error"), "{err}");
-}
-#[test]
-fn extend_removed() {
-    let dir = TempDir::new().unwrap();
-    let entry = dir.path().join("main.plum");
-    fs::write(&entry, "extend Foo =\n  fun f() -> Unit =\n    todo\n").unwrap();
-    let err = loadAndMerge(&entry, dir.path()).unwrap_err();
-    assert!(err.contains("parse error"), "{err}");
-}
 #[test]
 fn primitive_builtin_std_only() {
     // A built-in's API can only be declared in std.

plum-core/tests/parser_test.rs CHANGED Viewed

@@ -85,31 +85,6 @@ enum Cat =
     assert_eq!(set_name.type_param, Some("Cat".to_string()));
 }
-#[test]
-fn nestedEnumMethodBecomesTopLevelFnItemWithTypeParamSet() {
-    let src = "\
-enum Step =
-  | ReadMin
-  | ReadMax
-  fun toNumber(self) -> Int =
-    match self
-      ReadMin => 0
-      ReadMax => 1
-";
-    let source = parse(src);
-    assert_eq!(source.items.len(), 2, "enum + 1 nested method, in order");
-    let Item::Enum(e) = &source.items[0] else {
-        panic!("expected an Enum item first")
-    };
-    assert_eq!(e.name, "Step");
-    let Item::Fn(to_number) = &source.items[1] else {
-        panic!("expected toNumber immediately after the enum")
-    };
-    assert_eq!(to_number.name, "toNumber");
-    assert_eq!(to_number.type_param, Some("Step".to_string()));
-}
 #[test]
 fn enumDiscriminantValuesParseIntoParamsAndVariantValues() {
     let src = "\
@@ -135,26 +110,6 @@ enum Step(n: Int) =
     assert_eq!(e.variants[1].values, vec![Expr::Int(1)]);
 }
-#[test]
-fn classAndEnumWithNoNestedMethodsProduceNoExtraFnItems() {
-    let src = "\
-enum Dog =
-  | Dog(name: Str)
-enum Flag =
-  | On
-  | Off
-";
-    let source = parse(src);
-    assert_eq!(
-        source.items.len(),
-        2,
-        "no nested methods means no extra Item::Fn entries"
-    );
-    assert!(matches!(source.items[0], Item::Enum(_)));
-    assert!(matches!(source.items[1], Item::Enum(_)));
-}
 #[test]
 fn closureLiteralParsesWithParamsAndBody() {
     let src = "\
@@ -178,28 +133,6 @@ fun useClosure() -> Bool =
     assert_eq!(closure.body.stmts.len(), 1);
 }
-#[test]
-fn closureLiteralParsesWithNoParams() {
-    let src = "\
-fun useClosure() -> Bool =
-  cb = ||
-    true
-  cb()
-";
-    let source = parse(src);
-    let f = onlyFn(&source);
-    let FnBody::Block(block) = &f.body else {
-        panic!("expected a block body")
-    };
-    let Stmt::Assign(assign) = &block.stmts[0] else {
-        panic!("expected an assign statement")
-    };
-    let Expr::Closure(closure) = &assign.values[0] else {
-        panic!("expected a closure expression")
-    };
-    assert!(closure.params.is_empty());
-}
 #[test]
 fn fnWithoutReceiverButWithReturnTypeHasNoTypeParam() {
     let src = "fun main() -> Int =\n  0\n";
@@ -215,18 +148,6 @@ fn fnWithoutReceiverButWithReturnTypeHasNoTypeParam() {
     );
 }
-#[test]
-fn nestedMethodWithReturnTypeHasCorrectTypeParam() {
-    let src = "enum Cat =\n  | Cat(name: Str)\n\n  fun toStr() -> Str =\n    \"x\"\n";
-    let source = parse(src);
-    let f = onlyFn(&source);
-    assert_eq!(f.type_param, Some("Cat".to_string()));
-    assert_eq!(
-        f.returns.as_ref().map(|t| t.name.clone()),
-        Some("Str".to_string())
-    );
-}
 #[test]
 fn fnValueTypeParamParsesWithPositionalTypesAndReturn() {
     let src = "fun each(cb: fn(Int) -> Bool) -> Bool =\n  true\n";
@@ -266,18 +187,6 @@ fn bound_syntax_rejected() {
     assert!(hasParseError("fun f[T: Show](x: T) -> T =\n  x\n"));
 }
-#[test]
-fn fnValueTypeParamParsesWithNoReturn() {
-    let src = "fun each(cb: fn(Int)) -> Bool =\n  true\n";
-    let source = parse(src);
-    let f = onlyFn(&source);
-    let ParamType::Fn(param_types, ret) = &f.params[0].ty else {
-        panic!("expected ParamType::Fn")
-    };
-    assert_eq!(param_types.len(), 1);
-    assert!(ret.is_none());
-}
 // ---- errors: `!T`, `T?`, postfix `?`, `crash` ----
 fn parseHasError(src: &str) -> bool {
@@ -306,29 +215,11 @@ fn test_tag_union_types_are_syntax_errors() {
     assert!(parseHasError("fun f() -> Int ! [A, B] = 1\n"));
 }
-#[test]
-fn test_slice_type_still_parses() {
-    let src = parse("fun f(x: []Byte) -> Int = 1\n");
-    match &onlyFn(&src).params[0].ty {
-        ParamType::Type(t) => assert_eq!(t.name, "[]Byte"),
-        _ => panic!(),
-    }
-}
 #[test]
 fn test_double_question_expression_is_a_syntax_error() {
     assert!(parseHasError("fun f(a: Int, b: Int) -> Int = a ?? b\n"));
 }
-#[test]
-fn elvis_parses_to_an_elvis_catch() {
-    let src = parse("fun f(a: Int?, b: Int) -> Int = a ?: b\n");
-    match bodyExpr(onlyFn(&src)) {
-        Expr::Catch(c) => assert!(c.elvis),
-        other => panic!("got {:?}", other),
-    }
-}
 #[test]
 fn elvis_is_right_associative() {
     let src = parse("fun f(a: Int?, b: Int?) -> Int = a ?: b ?: 1\n");
@@ -379,12 +270,6 @@ fn int_min_literal() {
     assert!(matches!(bodyExpr(onlyFn(&src)), Expr::Int(i64::MIN)));
 }
-#[test]
-fn inline_if_expression() {
-    let src = parse("fun f(c: Bool) -> Int = if c then 1 else 2\n");
-    assert!(matches!(bodyExpr(onlyFn(&src)), Expr::InlineIf(_)));
-}
 #[test]
 fn inline_if_chain() {
     let src = parse("fun f(a: Bool, b: Bool) -> Int = if a then 1 else if b then 2 else 3\n");
@@ -410,24 +295,6 @@ fn question_binds_tight() {
     assert!(matches!(bodyExpr(g), Expr::Binary(_)), "got {:?}", bodyExpr(g));
 }
-#[test]
-fn test_try_plain() {
-    let src = parse("fun f() -> Int = try g()\n");
-    assert!(matches!(bodyExpr(onlyFn(&src)), Expr::Try(_)));
-}
-#[test]
-fn test_crash_stmt() {
-    let src = parse("fun f() -> Int =\n  crash \"boom\"\n");
-    match &onlyFn(&src).body {
-        FnBody::Block(b) => match &b.stmts[0] {
-            Stmt::Crash(Expr::String(_)) => {}
-            other => panic!("expected Crash(String), got {other:?}"),
-        },
-        _ => panic!(),
-    }
-}
 fn firstExprDebug(src: &str) -> String {
     let s = parse(src);
     format!("{:?}", onlyFn(&s).body)
@@ -656,12 +523,6 @@ fn catch_error_value_and_block_forms() {
     assert!(matches!(&c.handler, CatchHandler::Default(Expr::Var(_))));
 }
-#[test]
-fn return_error_statement() {
-    let s = parse("fun f() -> !Int =\n  if x\n    return error.Bad\n  1\n");
-    assert!(matches!(bodyExpr(onlyFn(&s)), Expr::Int(1)));
-}
 #[test]
 fn pattern_if_conditions_parse() {
     let src = parse("enum Sh =\n  | Circle(r: Int)\n  | Rect(w: Int, h: Int)\n\nfun f(s: Sh) -> Int =\n  if Circle(r) := s\n    return r\n  else if Rect(w, _) := s, w > 1, w < 9\n    return w\n  0\n");
@@ -720,15 +581,6 @@ fn pairArgDesugarsToPairCall() {
     }
 }
-#[test]
-fn pairArgMixedWithPositional() {
-    let args = firstCallArgs("fun main() =\n  x := f(1, \"a\" => 2)\n");
-    assert_eq!(args.len(), 2);
-    assert_eq!(args[0], Arg::Positional(Expr::Int(1)));
-    let p = pairArgs(&args[1]);
-    assert_eq!(p[1], Arg::Positional(Expr::Int(2)));
-}
 #[test]
 fn pairArgTrailingComma() {
     let args = firstCallArgs("fun main() =\n  x := f(\"a\" => 1,)\n");
@@ -736,15 +588,6 @@ fn pairArgTrailingComma() {
     pairArgs(&args[0]);
 }
-#[test]
-fn pairKeyAnyExpression() {
-    let args = firstCallArgs("fun main() =\n  x := f(1 => \"x\", k => \"y\", n + 1 => \"z\")\n");
-    assert_eq!(args.len(), 3);
-    for a in &args {
-        pairArgs(a);
-    }
-}
 #[test]
 fn pairArgCallCarriesPairPosition() {
     let args = firstCallArgs("fun main() =\n  x := f(1, \"a\" => 2)\n");
@@ -772,15 +615,6 @@ fn digitNameCallsAreCallsNotConsts() {
     assert_eq!(args.len(), 1);
 }
-#[test]
-fn screamingConstsStayConsts() {
-    let src = parse("fun f() =\n  a := MAX\n  b := V2.K1\n  c := BUCKET_COUNT\n");
-    match &onlyFn(&src).body {
-        FnBody::Block(b) => assert_eq!(b.stmts.len(), 3),
-        o => panic!("{o:?}"),
-    }
-}
 #[test]
 fn parseStructNoBody() {
     let s = parse("struct Vec2(x: Float, y: Float)");
@@ -793,6 +627,7 @@ fn parseStructNoBody() {
     assert_eq!(e.variants[0].name, "Vec2");
     assert_eq!(e.variants[0].field_names, vec!["x", "y"]);
     assert_eq!(e.variants[0].fields[0].name, "Float");
+    assert!(e.variants[0].member.is_none());
 }
 #[test]
@@ -828,18 +663,6 @@ fn parseRecordFnField() {
     assert_eq!(f[1].name, "T");
 }
-#[test]
-fn struct_no_body_then_fun() {
-    let s = parse("struct Aa(x: Int)\nfun f() -> Int = 1");
-    assert_eq!(s.items.len(), 2);
-}
-#[test]
-fn struct_body_comment_before_fn() {
-    let s = parse("struct Vec2(x: Float) =\n  # c\n  fun f(self) -> Float = self.x\n");
-    assert_eq!(onlyEnum(&s).name, "Vec2");
-}
 #[test]
 fn value_enum_rejected() {
     assert!(hasParseError("value enum Vv =\n  | Vv(x: Int)\n"));
@@ -897,12 +720,6 @@ fn unionEnumMultiLineGenericMember() {
     assert_eq!(n.generics[0].name, "T");
 }
-#[test]
-fn one_line_then_fun() {
-    let source = parse("enum Sh = Ci | Re\nfun f() -> Int = 1");
-    assert_eq!(source.items.len(), 2);
-}
 #[test]
 fn one_line_generic_member() {
     let source = parseRaw("enum Js = JsNull | List[Js] | Map[Str, Js]");
@@ -914,14 +731,6 @@ fn one_line_generic_member() {
     assert_eq!(memberOf(&e.variants[2]).generics[0].name, "Str");
 }
-#[test]
-fn discriminant_unchanged() {
-    let source = parse("enum Step(n: Int) =\n  | ReadMin(10)\n");
-    let e = onlyEnum(&source);
-    assert_eq!(e.variants[0].values.len(), 1);
-    assert!(e.variants[0].member.is_none());
-}
 #[test]
 fn inline_payload_still_parses() {
     let source = parse("enum Sh =\n  | Circle(r: Float)\n  | Dot(Int)\n");
@@ -931,13 +740,6 @@ fn inline_payload_still_parses() {
     assert!(e.variants[1].member.is_none());
 }
-#[test]
-fn structHasNoMember() {
-    let source = parse("struct Vec2(x: Float, y: Float)");
-    let e = onlyEnum(&source);
-    assert!(e.variants[0].member.is_none());
-}
 fn firstAssign(src: &str) -> plum_core::ast::Assign {
     let source = parse(src);
     let f = onlyFn(&source);

plum-core/tests/unions_test.rs CHANGED Viewed

@@ -25,11 +25,6 @@ fn ty(n: &str) -> Type {
     Type { name: n.to_string(), generics: vec![] }
 }
-#[test]
-fn hiddenVariantName() {
-    assert_eq!(hiddenVariant("Shape", "Circle"), "Shape__Circle");
-}
 #[test]
 fn resolvesMemberAndTag() {
     let mut s = parse("struct Circle(r: Float)\nenum Shape = Circle | Red");
@@ -117,11 +112,3 @@ fn builtinMember() {
     assert_eq!(enumOf(&s, "Num").variants[0].name, "Num__Int");
 }
-#[test]
-fn legacyErrorsReported() {
-    let s = parse("enum Sh =\n  | Circle(r: Float)\nenum User =\n  | User(n: Int)\n");
-    let errs = legacyErrors(&s);
-    assert_eq!(errs.len(), 2);
-    assert!(errs[0].starts_with("inline variant payloads are removed: declare record Circle(...)"));
-    assert!(errs[1].contains("enum User has a single variant named User"));
-}