@mpeggroup/mpeg-sdl-parser 4.0.0

package/tests/prettier/print-elementary-type.test.ts

@@ -0,0 +1,62 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print Elementary Type tests", () => {
+  test("prettified elementary type output is as expected", async () => {
+    await testPrettierScenario(
+      "class A{aligned(16) bit(2) adaptation_field_control = 0x0000.0000;}",
+      "class A {\n" +
+        "  aligned(16) bit(2) adaptation_field_control = 0x0000.0000;\n" +
+        "}\n",
+      "class A {\n" +
+        "  aligned(16) bit(2) adaptation_field_control =\n" +
+        "    0x0000.0000;\n" +
+        "}\n",
+    );
+  });
+
+  test("prettified elementary type with embedded comments output is as expected", async () => {
+    await testPrettierScenario(
+      "class A{aligned(16) bit(2) // hello \nadaptation_field_control = 0x0000.0000;}",
+      "class A {\n" +
+        "  aligned(16) bit(2) // hello\n" +
+        "    adaptation_field_control = 0x0000.0000;\n" +
+        "}\n",
+      "class A {\n" +
+        "  aligned(16) bit(2) // hello\n" +
+        "    adaptation_field_control = 0x0000.0000;\n" +
+        "}\n",
+    );
+  });
+
+  test("prettified computed elementary type output is as expected", async () => {
+    await testPrettierScenario(
+      "class A{computed unsigned int adaptation_field_control = 0x0000.0000;}",
+      "class A {\n" +
+        "  computed unsigned int adaptation_field_control = 0x0000.0000;\n" +
+        "}\n",
+      "class A {\n" +
+        "  computed unsigned int\n" +
+        "    adaptation_field_control =\n" +
+        "    0x0000.0000;\n" +
+        "}\n",
+    );
+  });
+
+  test("prettified computed elementary type with embedded comments in nested indent output is as expected", async () => {
+    await testPrettierScenario(
+      "class A{if (i) computed unsigned int adaptation_field_control = // foo \n0x0000.0000;}",
+      "class A {\n" +
+        "  if (i)\n" +
+        "    computed unsigned int adaptation_field_control = // foo\n" +
+        "      0x0000.0000;\n" +
+        "}\n",
+      "class A {\n" +
+        "  if (i)\n" +
+        "    computed unsigned int\n" +
+        "      adaptation_field_control = // foo\n" +
+        "      0x0000.0000;\n" +
+        "}\n",
+    );
+  });
+});

package/tests/prettier/print-error.test.ts

@@ -0,0 +1,40 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print Error tests", () => {
+  test("prettified error output is as expected 1", async () => {
+    await testPrettierScenario(
+      "class A {bit b;}",
+      "class A {\n" +
+        "  bit\n" +
+        "  b;\n" +
+        "}\n",
+      "class A {\n" +
+        "  bit\n" +
+        "  b;\n" +
+        "}\n",
+    );
+  });
+
+  test("prettified error output is as expected 2", async () => {
+    await testPrettierScenario(
+      "class A {if (adaptation_ field_control == 0b01 || adaptation_field_control == 0b11) {}}",
+      "class A {\n" +
+        "  if (adaptation_\n" +
+        "\n" +
+        "  field_control == 0b01 || adaptation_field_control == 0b11)\n" +
+        "  {\n" +
+        "  }\n" +
+        "}\n",
+      "class A {\n" +
+        "  if (adaptation_\n" +
+        "\n" +
+        "  field_control == 0b01 ||\n" +
+        "    adaptation_field_control ==\n" +
+        "    0b11)\n" +
+        "  {\n" +
+        "  }\n" +
+        "}\n",
+    );
+  });
+});

package/tests/prettier/print-expression.test.ts

@@ -0,0 +1,17 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print Expression tests", () => {
+  test("prettified expression output is as expected", async () => {
+    await testPrettierScenario(
+      "class A{N = 1 - data.adaptation_field_length_longer;}",
+      "class A {\n" +
+        "  N = 1 - data.adaptation_field_length_longer;\n" +
+        "}\n",
+      "class A {\n" +
+        "  N = 1 -\n" +
+        "    data.adaptation_field_length_longer;\n" +
+        "}\n",
+    );
+  });
+});

package/tests/prettier/print-for.test.ts

@@ -0,0 +1,23 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print For tests", () => {
+  test("prettified for output is as expected", async () => {
+    await testPrettierScenario(
+      "class A{for(computed int long_variable_name = 0;long_variable_name<2; long_variable_name++){another_long_variable_name = long_variable_name + 2;}}",
+      "class A {\n" +
+        "  for (computed int long_variable_name = 0; long_variable_name < 2; long_variable_name++) {\n" +
+        "    another_long_variable_name = long_variable_name + 2;\n" +
+        "  }\n" +
+        "}\n",
+      "class A {\n" +
+        "  for (computed int long_variable_name =\n" +
+        "    0; long_variable_name < 2; long_variable_name++) {\n" +
+        "    another_long_variable_name =\n" +
+        "      long_variable_name +\n" +
+        "      2;\n" +
+        "  }\n" +
+        "}\n",
+    );
+  });
+});

package/tests/prettier/print-if.test.ts

@@ -0,0 +1,71 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print If tests", () => {
+  test("prettified if output is as expected", async () => {
+    await testPrettierScenario(
+      "class A{if (very_long_variable_name + another_long_variable_name > 0) { a[long_variable_name] = long_variable_name + 1; } else if (long_variable_name + another_long_variable_name > 0) { do_something++; } else { do_something_else++; }}",
+      "class A {\n" +
+        "  if (very_long_variable_name + another_long_variable_name > 0) {\n" +
+        "    a[long_variable_name] = long_variable_name + 1;\n" +
+        "  }\n" +
+        "  else if (long_variable_name + another_long_variable_name > 0) {\n" +
+        "    do_something++;\n" +
+        "  }\n" +
+        "  else {\n" +
+        "    do_something_else++;\n" +
+        "  }\n" +
+        "}\n",
+      "class A {\n" +
+        "  if (very_long_variable_name +\n" +
+        "    another_long_variable_name > 0) {\n" +
+        "    a[long_variable_name] =\n" +
+        "      long_variable_name +\n" +
+        "      1;\n" +
+        "  }\n" +
+        "  else if (long_variable_name +\n" +
+        "    another_long_variable_name > 0) {\n" +
+        "    do_something++;\n" +
+        "  }\n" +
+        "  else {\n" +
+        "    do_something_else++;\n" +
+        "  }\n" +
+        "}\n",
+    );
+  });
+
+  test("prettified if output without compound if and without compound else statement is as expected", async () => {
+    await testPrettierScenario(
+      "class A{if (i) i++; else i--;}",
+      "class A {\n" +
+        "  if (i)\n" +
+        "    i++;\n" +
+        "  else\n" +
+        "    i--;\n" +
+        "}\n",
+      "class A {\n" +
+        "  if (i)\n" +
+        "    i++;\n" +
+        "  else\n" +
+        "    i--;\n" +
+        "}\n",
+    );
+  });
+
+  test("prettified if output with complex condition", async () => {
+    await testPrettierScenario(
+      "class A{if (adaptation_field_control == 0b01 || adaptation_field_control == 0b11) \n\n{ bit(8) data_byte[N]; }}",
+      "class A {\n" +
+        "  if (adaptation_field_control == 0b01 || adaptation_field_control == 0b11) {\n" +
+        "    bit(8) data_byte[N];\n" +
+        "  }\n" +
+        "}\n",
+      "class A {\n" +
+        "  if (adaptation_field_control == 0b01 ||\n" +
+        "    adaptation_field_control == 0b11) {\n" +
+        "    bit(8) data_byte[N];\n" +
+        "  }\n" +
+        "}\n",
+    );
+  });
+});

package/tests/prettier/print-number-literal.test.ts

@@ -0,0 +1,28 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print Number Literal tests", () => {
+  test("prettified binary number literal is as expected", async () => {
+    await testPrettierScenario(
+      "class A{bit(8)b=0b1101.1101;}\n",
+      "class A {\n" +
+        "  bit(8) b = 0b1101.1101;\n" +
+        "}\n",
+      "class A {\n" +
+        "  bit(8) b = 0b1101.1101;\n" +
+        "}\n",
+    );
+  });
+
+  test("prettified multi-character number literal is as expected", async () => {
+    await testPrettierScenario(
+      "class A{bit(8)b='abcd''efgh';}\n",
+      "class A {\n" +
+        "  bit(8) b = 'abcd' 'efgh';\n" +
+        "}\n",
+      "class A {\n" +
+        "  bit(8) b = 'abcd' 'efgh';\n" +
+        "}\n",
+    );
+  });
+});

package/tests/prettier/print-specification.test.ts

@@ -0,0 +1,54 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print Specification tests", () => {
+  test("prettified specification output is as expected", async () => {
+    await testPrettierScenario(
+      "computed int i;computed int j;class A{i++;}class B{j++;}\n",
+      "computed int i;\n" +
+        "computed int j;\n" +
+        "\n" +
+        "class A {\n" +
+        "  i++;\n" +
+        "}\n" +
+        "\n" +
+        "class B {\n" +
+        "  j++;\n" +
+        "}\n",
+      "computed int i;\n" +
+        "computed int j;\n" +
+        "\n" +
+        "class A {\n" +
+        "  i++;\n" +
+        "}\n" +
+        "\n" +
+        "class B {\n" +
+        "  j++;\n" +
+        "}\n",
+    );
+  });
+
+  test("prettified specification output is as expected for empty specification", async () => {
+    await testPrettierScenario(
+      "\n",
+      "",
+      "",
+    );
+  });
+
+  test("prettified specification output is as expected for single invalid token", async () => {
+    await testPrettierScenario(
+      "§\n",
+      "§\n",
+      "§\n",
+    );
+  });
+
+  test("prettified specification output is as expected for only a comment", async () => {
+    await testPrettierScenario(
+      "// Start typing your SDL here... <Ctrl+Space> for completions\n",
+      "// Start typing your SDL here... <Ctrl+Space> for completions\n",
+      "// Start typing your SDL here... <Ctrl+Space> for completions\n",
+    );
+  });
+});

package/tests/prettier/print-string.test.ts

@@ -0,0 +1,36 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print String tests", () => {
+  test("prettified UTF8 string output is as expected", async () => {
+    await testPrettierScenario(
+      'class A{reserved // odd comment location \nconst utf8string foo_with_an_extra_long_name = u"big_long_bar" u"foo_which_is_even_longer" u"u";}',
+      "class A {\n" +
+        "  reserved // odd comment location\n" +
+        '    const utf8string foo_with_an_extra_long_name = u"big_long_bar" u"foo_which_is_even_longer" u"u";\n' +
+        "}\n",
+      "class A {\n" +
+        "  reserved // odd comment location\n" +
+        "    const utf8string foo_with_an_extra_long_name =\n" +
+        '    u"big_long_bar"\n' +
+        '    u"foo_which_is_even_longer" u"u";\n' +
+        "}\n",
+    );
+  });
+
+  test("prettified Base64 string output is as expected", async () => {
+    await testPrettierScenario(
+      'class A{reserved // odd comment location \nconst base64string foo_with_an_extra_long_name = "ABCDABCD" "ABCDABCDABCDABCDABCDABCD";}',
+      "class A {\n" +
+        "  reserved // odd comment location\n" +
+        '    const base64string foo_with_an_extra_long_name = "ABCDABCD" "ABCDABCDABCDABCDABCDABCD";\n' +
+        "}\n",
+      "class A {\n" +
+        "  reserved // odd comment location\n" +
+        "    const base64string foo_with_an_extra_long_name =\n" +
+        '    "ABCDABCD"\n' +
+        '    "ABCDABCDABCDABCDABCDABCD";\n' +
+        "}\n",
+    );
+  });
+});

package/tests/prettier/print-switch.test.ts

@@ -0,0 +1,69 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print Switch tests", () => {
+  test("prettified switch output is as expected", async () => {
+    await testPrettierScenario(
+      "class A{switch (long_variable_name) { case 1: something = something + another_thing; break; case 2: do_something_else++; break; default: do_default++; }}",
+      "class A {\n" +
+        "  switch (long_variable_name) {\n" +
+        "    case 1:\n" +
+        "      something = something + another_thing;\n" +
+        "      break;\n" +
+        "    case 2:\n" +
+        "      do_something_else++;\n" +
+        "      break;\n" +
+        "    default:\n" +
+        "      do_default++;\n" +
+        "  }\n" +
+        "}\n",
+      "class A {\n" +
+        "  switch (long_variable_name) {\n" +
+        "    case 1:\n" +
+        "      something = something +\n" +
+        "        another_thing;\n" +
+        "      break;\n" +
+        "    case 2:\n" +
+        "      do_something_else++;\n" +
+        "      break;\n" +
+        "    default:\n" +
+        "      do_default++;\n" +
+        "  }\n" +
+        "}\n",
+    );
+  });
+
+  test("prettified switch with trivia output is as expected", async () => {
+    await testPrettierScenario(
+      "class A { switch (i) {\n    case 0:\n   case 1:\n\n            // nothing\n      break;\n   case 2: \n\n            { // nothing\n      break;\n      }\n    default:\n      i++;\n      //     foo\n  }}\n",
+      "class A {\n" +
+        "  switch (i) {\n" +
+        "    case 0:\n" +
+        "    case 1:\n" +
+        "      // nothing\n" +
+        "      break;\n" +
+        "    case 2: { // nothing\n" +
+        "      break;\n" +
+        "    }\n" +
+        "    default:\n" +
+        "      i++;\n" +
+        "    // foo\n" +
+        "  }\n" +
+        "}\n",
+      "class A {\n" +
+        "  switch (i) {\n" +
+        "    case 0:\n" +
+        "    case 1:\n" +
+        "      // nothing\n" +
+        "      break;\n" +
+        "    case 2: { // nothing\n" +
+        "      break;\n" +
+        "    }\n" +
+        "    default:\n" +
+        "      i++;\n" +
+        "    // foo\n" +
+        "  }\n" +
+        "}\n",
+    );
+  });
+});

package/tests/prettier/print-while.test.ts

@@ -0,0 +1,23 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print While tests", () => {
+  test("prettified while output is as expected", async () => {
+    await testPrettierScenario(
+      "class A{while (very_long_variable_name + another_long_variable_name > 0) { a[long_variable_name] = long_variable_name + 1; }}",
+      "class A {\n" +
+        "  while (very_long_variable_name + another_long_variable_name > 0) {\n" +
+        "    a[long_variable_name] = long_variable_name + 1;\n" +
+        "  }\n" +
+        "}\n",
+      "class A {\n" +
+        "  while (very_long_variable_name +\n" +
+        "    another_long_variable_name > 0) {\n" +
+        "    a[long_variable_name] =\n" +
+        "      long_variable_name +\n" +
+        "      1;\n" +
+        "  }\n" +
+        "}\n",
+    );
+  });
+});

package/tests/prettier/test-prettier-scenario.ts

@@ -0,0 +1,41 @@
+import * as prettier from "prettier";
+import { expect } from "bun:test";
+import { prettierPluginSdl } from "../../src/prettier/prettier-plugin-sdl.ts";
+import { createLenientSdlParser } from "../../src/lezer/create-sdl-parser.ts";
+import { SdlStringInput } from "../../index.ts";
+
+const lenientSdlParser = createLenientSdlParser();
+
+export async function testPrettierScenario(
+  source: string,
+  expected: string,
+  expectedNarrow: string,
+) {
+  const options: prettier.Options = {
+    parser: "sdl",
+    plugins: [prettierPluginSdl],
+    // test wide
+    printWidth: 160,
+  };
+
+  let prettified = await prettier.format(source, options);
+
+  expect(prettified).toEqual(expected);
+
+  // check that the prettified output is valid SDL
+  let sdlStringInput = new SdlStringInput(prettified);
+
+  lenientSdlParser.parse(sdlStringInput);
+
+  // test narrow
+  options.printWidth = 40;
+
+  prettified = await prettier.format(source, options);
+
+  expect(prettified).toEqual(expectedNarrow);
+
+  // check that the prettified output is valid SDL
+  sdlStringInput = new SdlStringInput(prettified);
+
+  lenientSdlParser.parse(sdlStringInput);
+}