diff --git a/.github/bin/run-format.sh b/.github/bin/run-format.sh
index 3c1c724..d5ccfa1 100755
--- a/.github/bin/run-format.sh
+++ b/.github/bin/run-format.sh
@@ -31,10 +31,16 @@
 
 FORMAT_OUT=${TMPDIR:-/tmp}/clang-format-diff.out
 
-# Use the provided Clang format binary, or try to fallback to clang-format-17
-# or clang-format.
+# Use the provided Clang format binary, or try clang-format-19 (CI version),
+# then older numbered versions, then unversioned clang-format.
 if [[ ! -v CLANG_FORMAT ]]; then
-  if command -v "clang-format-17" 2>&1 >/dev/null
+  if command -v "clang-format-19" 2>&1 >/dev/null
+  then
+    CLANG_FORMAT="clang-format-19"
+  elif command -v "clang-format-18" 2>&1 >/dev/null
+  then
+    CLANG_FORMAT="clang-format-18"
+  elif command -v "clang-format-17" 2>&1 >/dev/null
   then
     CLANG_FORMAT="clang-format-17"
   elif command -v "clang-format" 2>&1 >/dev/null
@@ -44,6 +50,7 @@
     (echo "-- Missing the clang-format binary! --"; exit 1)
   fi
 fi
+echo "Using ${CLANG_FORMAT} ($("${CLANG_FORMAT}" --version))"
 
 BUILDIFIER=${BUILDIFIER:-buildifier}
 
diff --git a/.github/bin/smoke-projects.hashes b/.github/bin/smoke-projects.hashes
new file mode 100644
index 0000000..5298441
--- /dev/null
+++ b/.github/bin/smoke-projects.hashes
@@ -0,0 +1,20 @@
+a12778b40ae905f82eb2c23ea4ac037f98099fae https://github.com/jamieiles/80x86
+4da15979747f326bde2f9869c64e587ce599772c https://github.com/pulp-platform/axi
+b48037e28544425839dbd617d45b1a82631bc1a9 https://github.com/bespoke-silicon-group/basejump_stl
+f91010f654a5dfd00f83dbe25dbda482218d540b https://github.com/black-parrot/black-parrot
+86d09682492176a1f8fd1732e469bc2d309453a3 https://github.com/chipsalliance/caliptra-rtl
+f9fbd09655ec6ee457438140c13a168390ebd043 https://github.com/chipsalliance/Cores-VeeR-EH2
+3ac6208ed0210ff66a557dd7dc4e79e34f1f2f4a https://github.com/openhwgroup/cva6
+0602ee4627b10f301298f2673d826cdd6baa9327 https://github.com/ijor/fx68k
+8b8ee086aef72e0833b7f0493d9d33f1e4d3c8e2 https://github.com/lowRISC/ibex
+a19e629a1879801ffcc6f2e6256ca435c20570f3 https://github.com/steveicarus/ivtest
+8e83643c22a3ba7612a9bb9cec93292dad618ab5 https://github.com/trivialmips/nontrivial-mips
+00981352642fb65ef2b6c47143a0f6bb31fd4a97 https://github.com/lowRISC/opentitan
+491a4dc9bb25c33e0183caaf683102b9ce273bc1 https://github.com/gtaylormb/opl3_fpga
+7b65f6ba0bce58d4d859082660123b7100aae975 https://github.com/rsd-devel/rsd
+ebb5e3551a9d93c0ee95f0b767dd878b8927e702 https://github.com/syntacore/scr1
+f200eb2ed7b69ac1c6b8eddd47654522aeee5ce8 https://github.com/olofk/serv
+c4229f3bd5220e6d3ba8f390e5d09c87e462e9c7 https://github.com/chipsalliance/sv-tests
+7e9841ff775ea22fba3f222f7bdfe35668345e00 https://github.com/taichi-ishitani/tnoc
+5d72b6618acfddece7f09382a032ccbc05862fdc https://github.com/SymbiFlow/uvm
+1c8e05fd1e9a79ceb8b996a0996674122eed086f https://github.com/SymbiFlow/XilinxUnisimLibrary
diff --git a/.github/bin/smoke-test.sh b/.github/bin/smoke-test.sh
index ba3ff96..5532187 100755
--- a/.github/bin/smoke-test.sh
+++ b/.github/bin/smoke-test.sh
@@ -29,16 +29,13 @@
 # crash Verible, we're good.
 ###
 
-# Suppress '... aborted' messages bash would print when a tool crashes.
-# Comment out to see syntax errors in bash while working on script.
-exec 2>/dev/null
-
 set -u   # Be strict: only allow using a variable after it is assigned
 
 BAZEL_BUILD_OPTIONS="-c opt"
 
 TMPDIR="${TMPDIR:-/tmp}"
 readonly BASE_TEST_DIR="${TMPDIR}/test/verible-smoke-test"
+readonly PROJECT_HASHES_FILE="$(dirname $0)/smoke-projects.hashes"
 
 # Write log files to this directory
 readonly SMOKE_LOGGING_DIR="${SMOKE_LOGGING_DIR:-$BASE_TEST_DIR/error-logs}"
@@ -81,29 +78,11 @@
 #
 # There are some known issues which are all recorded in the associative
 # array below, mapping them to Verible issue tracker numbers.
-# TODO(hzeller): there should be a configuration file that contains two
-# columns: URL + hash, so that we can fetch a particular known version not
-# a moving target.
-readonly TEST_GIT_PROJECTS="https://github.com/lowRISC/ibex \
-         https://github.com/lowRISC/opentitan \
-         https://github.com/chipsalliance/sv-tests \
-         https://github.com/chipsalliance/Cores-VeeR-EH2 \
-         https://github.com/chipsalliance/caliptra-rtl \
-         https://github.com/openhwgroup/cva6 \
-         https://github.com/SymbiFlow/uvm \
-         https://github.com/taichi-ishitani/tnoc \
-         https://github.com/ijor/fx68k \
-         https://github.com/jamieiles/80x86 \
-         https://github.com/SymbiFlow/XilinxUnisimLibrary \
-         https://github.com/black-parrot/black-parrot
-         https://github.com/steveicarus/ivtest \
-         https://github.com/trivialmips/nontrivial-mips \
-         https://github.com/pulp-platform/axi \
-         https://github.com/rsd-devel/rsd \
-         https://github.com/syntacore/scr1 \
-         https://github.com/olofk/serv \
-         https://github.com/bespoke-silicon-group/basejump_stl \
-         https://github.com/gtaylormb/opl3_fpga"
+
+if [ ! -f "${PROJECT_HASHES_FILE}" ]; then
+  echo "Project hashes file not found: ${PROJECT_HASHES_FILE}"
+  exit 1
+fi
 
 ##
 # Some of the files in the projects will have issues.
@@ -135,24 +114,24 @@
 
 ExpectedFailCount[syntax:ibex]=13
 ExpectedFailCount[lint:ibex]=13
-ExpectedFailCount[project:ibex]=218
-ExpectedFailCount[preprocessor:ibex]=397
+ExpectedFailCount[project:ibex]=224
+ExpectedFailCount[preprocessor:ibex]=403
 
 ExpectedFailCount[syntax:opentitan]=88
 ExpectedFailCount[lint:opentitan]=88
-ExpectedFailCount[project:opentitan]=1068
+ExpectedFailCount[project:opentitan]=1077
 ExpectedFailCount[formatter:opentitan]=0
-ExpectedFailCount[preprocessor:opentitan]=3074
+ExpectedFailCount[preprocessor:opentitan]=3017
 
 ExpectedFailCount[syntax:sv-tests]=74
 ExpectedFailCount[lint:sv-tests]=73
 ExpectedFailCount[project:sv-tests]=176
-ExpectedFailCount[preprocessor:sv-tests]=128
+ExpectedFailCount[preprocessor:sv-tests]=129
 
-ExpectedFailCount[syntax:caliptra-rtl]=39
-ExpectedFailCount[lint:caliptra-rtl]=38
-ExpectedFailCount[project:caliptra-rtl]=453
-ExpectedFailCount[preprocessor:caliptra-rtl]=911
+ExpectedFailCount[syntax:caliptra-rtl]=41
+ExpectedFailCount[lint:caliptra-rtl]=40
+ExpectedFailCount[project:caliptra-rtl]=474
+ExpectedFailCount[preprocessor:caliptra-rtl]=993
 
 ExpectedFailCount[syntax:Cores-VeeR-EH2]=2
 ExpectedFailCount[lint:Cores-VeeR-EH2]=2
@@ -164,10 +143,10 @@
 ExpectedFailCount[project:cva6]=84
 ExpectedFailCount[preprocessor:cva6]=140
 
-ExpectedFailCount[syntax:uvm]=0
-ExpectedFailCount[lint:uvm]=0
-ExpectedFailCount[project:uvm]=40
-ExpectedFailCount[preprocessor:uvm]=126
+ExpectedFailCount[syntax:uvm]=1
+ExpectedFailCount[lint:uvm]=1
+ExpectedFailCount[project:uvm]=41
+ExpectedFailCount[preprocessor:uvm]=128
 
 ExpectedFailCount[syntax:tnoc]=3
 ExpectedFailCount[lint:tnoc]=3
@@ -187,9 +166,9 @@
 ExpectedFailCount[project:black-parrot]=172
 ExpectedFailCount[preprocessor:black-parrot]=173
 
-ExpectedFailCount[syntax:ivtest]=117
-ExpectedFailCount[lint:ivtest]=117
-ExpectedFailCount[project:ivtest]=146
+ExpectedFailCount[syntax:ivtest]=116
+ExpectedFailCount[lint:ivtest]=116
+ExpectedFailCount[project:ivtest]=145
 ExpectedFailCount[preprocessor:ivtest]=26
 
 ExpectedFailCount[syntax:nontrivial-mips]=2
@@ -237,11 +216,10 @@
   expected_count_key="${TOOL_SHORT_NAME}:${PROJECT_NAME}"
   if [[ -v ExpectedFailCount[${expected_count_key}] ]]; then
     expected_count=${ExpectedFailCount[${expected_count_key}]}
-    # We allow some 5% deviation from expected values before we complain loudly
-    local GRACE_VALUE=$(( ${expected_count} / 20 ))
-    if [ ${GRACE_VALUE} -lt 2 ]; then
-      GRACE_VALUE=2
-    fi
+
+    # Since we have a fixed set of projects and hashes, we don't allow any
+    # derivation from the expected value (used to be 5%)
+    local GRACE_VALUE=0
     if [ ${OBSERVED_NONZERO_COUNT} -gt ${expected_count} ] ; then
       local ALLOWED_UP_TO=$((${expected_count} + ${GRACE_VALUE}))
       if [ ${OBSERVED_NONZERO_COUNT} -gt ${ALLOWED_UP_TO} ]; then
@@ -254,6 +232,7 @@
     elif [ ${OBSERVED_NONZERO_COUNT} -lt ${expected_count} ] ; then
       echo "::notice:: 🎉 Yay, reduced non-zero exit count ${expected_count} -> ${OBSERVED_NONZERO_COUNT}"
       echo "Set ExpectedFailCount[${TOOL_SHORT_NAME}:${PROJECT_NAME}]=${OBSERVED_NONZERO_COUNT}"
+      return 1  # we still want the exact value to be recorded so actively fail
     fi
   else
     if [ ${OBSERVED_NONZERO_COUNT} -gt 0 ] ; then
@@ -270,11 +249,14 @@
 #
 # First parameter : project name
 # Second parameter: name of file containing a list of {System}Verilog files
+# Third parameter : git URL
+# Fourth parameter: git hash (optional, defaults to master)
 function run_smoke_test() {
   local PROJECT_FILE_LIST=${TMPDIR}/filelist.$$.list
   local PROJECT_NAME=$1
   local FILELIST=$2
   local GIT_URL=$3
+  local GIT_HASH=${4:-master}
   local NUM_FILES=$(wc -l < ${FILELIST})
   local result=0
 
@@ -355,7 +337,7 @@
         else
           # This is an so far unknown issue
           echo "::error:: 😱 ${single_file}: crash exit code $EXIT_CODE for $tool"
-          echo "Input File URL: ${GIT_URL}/blob/master/$(echo $single_file | cut -d/ -f6-)"
+          echo "Input File URL: ${GIT_URL}/blob/${GIT_HASH}/$(echo $single_file | cut -d/ -f6-)"
           head -15 ${PROJECT_FILE_TOOL_OUT}   # Might be useful in this case
           result=$((${result} + 1))
         fi
@@ -372,8 +354,55 @@
   return ${result}
 }
 
+# --- main
+
+KEEP_LOGS=0
+VERBOSE=0
+PROJECT_FILTER=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --keep-logs)
+      KEEP_LOGS=1
+      shift
+      ;;
+    --verbose|-v)
+      VERBOSE=1
+      shift
+      ;;
+    --filter=*)
+      PROJECT_FILTER="${1#*=}"
+      shift
+      ;;
+    --filter|-f)
+      if [[ $# -lt 2 ]]; then
+        echo "Error: $1 requires an argument." >&2
+        exit 1
+      fi
+      PROJECT_FILTER="$2"
+      shift 2
+      ;;
+    -h|--help)
+      echo "Usage: $0 [--keep-logs] [--verbose] [--filter=<name>]"
+      exit 0
+      ;;
+    *)
+      echo "Unknown option: $1" >&2
+      echo "Usage: $0 [--keep-logs] [--verbose] [--filter=<name>]" >&2
+      exit 1
+      ;;
+  esac
+done
+
+if [ ${VERBOSE} -eq 0 ]; then
+  # Suppress '... aborted' messages bash would print when a tool crashes.
+  exec 2>/dev/null
+fi
+
 mkdir -p "${BASE_TEST_DIR}"
-trap 'rm -rf -- "${BASE_TEST_DIR}"' EXIT
+if [ ${KEEP_LOGS} -eq 0 ]; then
+  trap 'rm -rf -- "${BASE_TEST_DIR}"' EXIT
+fi
 
 status_sum=0
 
@@ -388,18 +417,26 @@
 bazel build ${BAZEL_BUILD_OPTIONS} :install-binaries &
 
 # While compiling, run potentially slow network ops
-for git_project in ${TEST_GIT_PROJECTS} ; do
-  PROJECT_NAME="$(basename $git_project)"
+while read -r git_hash git_project _; do
+  [[ -z "${git_hash}" || "${git_hash}" =~ ^# ]] && continue
+  PROJECT_NAME="$(basename "${git_project}")"
+  if [[ -n "${PROJECT_FILTER}" && "${PROJECT_NAME}" != *"${PROJECT_FILTER}"* ]]; then
+    continue
+  fi
   PROJECT_DIR="${BASE_TEST_DIR}/${PROJECT_NAME}"
-  git clone ${git_project} ${PROJECT_DIR} 2>/dev/null &
-done
+  ( git clone "${git_project}" "${PROJECT_DIR}" && git -C "${PROJECT_DIR}" checkout -q "${git_hash}" ) 2>/dev/null &
+done < "${PROJECT_HASHES_FILE}"
 
 echo "base test dir ${BASE_TEST_DIR}; writing logs to ${SMOKE_LOGGING_DIR}"
 echo "Waiting... for compilation and project download finished"
 wait
 
-for git_project in ${TEST_GIT_PROJECTS} ; do
-  PROJECT_NAME="$(basename $git_project)"
+while read -r git_hash git_project _; do
+  [[ -z "${git_hash}" || "${git_hash}" =~ ^# ]] && continue
+  PROJECT_NAME="$(basename "${git_project}")"
+  if [[ -n "${PROJECT_FILTER}" && "${PROJECT_NAME}" != *"${PROJECT_FILTER}"* ]]; then
+    continue
+  fi
   PROJECT_DIR="${BASE_TEST_DIR}/${PROJECT_NAME}"
   # Already cloned above
 
@@ -412,17 +449,17 @@
   FILELIST="${PROJECT_DIR}/verible.filelist"
   find "${PROJECT_DIR}" -name "*.sv" -o -name "*.svh" -o -name "*.v" | sort > ${FILELIST}
 
-  run_smoke_test "${PROJECT_NAME}" "${FILELIST}" "${git_project}"
+  run_smoke_test "${PROJECT_NAME}" "${FILELIST}" "${git_project}" "${git_hash}"
   status_sum=$((${status_sum} + $?))
   echo
-done
+done < "${PROJECT_HASHES_FILE}"
 
 echo "::endgroup::"
 
-echo "There were a total of ${status_sum} new, undocumented issues."
+echo "There were a total of ${status_sum} mismatches"
 
 # Let's see if there are any issues that are fixed in the meantime.
-if [ "${#KnownIssue[@]}" -ne 0 ]; then
+if [ -z "${PROJECT_FILTER}" ] && [ "${#KnownIssue[@]}" -ne 0 ]; then
   echo "::warning ::There are ${#KnownIssue[@]} tool/file combinations, that no longer fail"
   declare -A DistinctIssues
   for key in "${!KnownIssue[@]}"; do
@@ -434,7 +471,10 @@
   for issue_id in "${!DistinctIssues[@]}"; do
     echo " 🐞 ${ISSUE_PREFIX}/${issue_id}"
   done
-  echo
+fi
+
+if [ ${KEEP_LOGS} -ne 0 ]; then
+  echo "Logs and project files kept in ${BASE_TEST_DIR} (error logs: ${SMOKE_LOGGING_DIR})"
 fi
 
 exit ${status_sum}
diff --git a/.github/workflows/verible-ci.yml b/.github/workflows/verible-ci.yml
index 5f03f2f..802a7a3 100644
--- a/.github/workflows/verible-ci.yml
+++ b/.github/workflows/verible-ci.yml
@@ -34,6 +34,11 @@
       with:
         fetch-depth: 0
 
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: 'stable'
+
     - name: Install Dependencies
       run: |
         sudo apt-get install clang-format-19
diff --git a/README.md b/README.md
index b813b76..047fb20 100644
--- a/README.md
+++ b/README.md
@@ -172,8 +172,9 @@
 
 Verible's code base is written in C++.
 
-To build, you need the [bazel] build system (Min version 7) and a C++20
-compatible compiler.
+To build, you need the [bazel] build system (get it from
+[bazel install][bazel-install] if not already on your system) and a
+C++20 compatible compiler.
 
 Use your package manager to install the dependencies; on a system with
 the nix package manager simply run `nix-shell` to get a build environment.
@@ -199,6 +200,8 @@
 bazel build -c opt --config=create_static_linked_executables //...
 ```
 
+See [Installation](#installation-1) for install.
+
 ### Optionally using local flex/bison for build
 
 Flex and Bison, that are needed for the parser generation, are compiled as part
@@ -283,6 +286,7 @@
 [UHDM] format. If you are interested in collaborating, contact us.
 
 [bazel]: https://bazel.build/
+[bazel-install]: https://bazel.build/install
 [SV-LRM]: https://ieeexplore.ieee.org/document/8299595
 [lint-rule-list]: https://chipsalliance.github.io/verible/lint.html
 [github-lint-action]: https://github.com/chipsalliance/verible-linter-action
diff --git a/shell.nix b/shell.nix
index 85163eb..408340b 100644
--- a/shell.nix
+++ b/shell.nix
@@ -8,6 +8,17 @@
   #verible_used_stdenv = pkgs.gcc15Stdenv;
   #verible_used_stdenv = pkgs.clang19Stdenv;
   bazel = pkgs.bazel_8;
+
+
+  userNixPath = ./user.nix;  # optional user config
+  userPackages =
+    if builtins.pathExists userNixPath
+    then
+      let loaded = import userNixPath;
+      in if builtins.isFunction loaded
+         then loaded { inherit pkgs; }
+         else loaded
+    else [];
 in
 verible_used_stdenv.mkDerivation {
   name = "verible-build-environment";
@@ -40,7 +51,7 @@
 
       llvmPackages_22.clang-tools    # for clang-tidy
       llvmPackages_19.clang-tools    # for clang-format
-    ];
+    ] ++ userPackages;
   shellHook = ''
       # clang tidy: use latest.
       export CLANG_TIDY=${pkgs.llvmPackages_22.clang-tools}/bin/clang-tidy
diff --git a/verible/common/util/BUILD b/verible/common/util/BUILD
index 48a2105..db499b4 100644
--- a/verible/common/util/BUILD
+++ b/verible/common/util/BUILD
@@ -22,7 +22,6 @@
     hdrs = ["auto-pop-stack.h"],
     deps = [
         ":logging",
-        "@abseil-cpp//absl/base:core_headers",
     ],
 )
 
diff --git a/verible/common/util/auto-pop-stack.h b/verible/common/util/auto-pop-stack.h
index 024ef05..58628eb 100644
--- a/verible/common/util/auto-pop-stack.h
+++ b/verible/common/util/auto-pop-stack.h
@@ -18,7 +18,6 @@
 #include <cstddef>
 #include <vector>
 
-#include "absl/base/attributes.h"
 #include "verible/common/util/logging.h"
 
 namespace verible {
@@ -29,7 +28,7 @@
 // implementing algorithms based on stack data structures like building
 // inheritance stack of traversed tree.
 template <typename T>
-class AutoPopStack {
+class [[maybe_unused]] AutoPopStack {
  public:
   using value_type = T;
   using this_type = AutoPopStack<value_type>;
@@ -105,7 +104,7 @@
 
  private:
   stack_type stack_;
-} ABSL_ATTRIBUTE_UNUSED;
+};
 
 }  // namespace verible
 
diff --git a/verible/common/util/container-proxy_test.cc b/verible/common/util/container-proxy_test.cc
index 5e8220f..4e4cd75 100644
--- a/verible/common/util/container-proxy_test.cc
+++ b/verible/common/util/container-proxy_test.cc
@@ -874,13 +874,14 @@
 
   const int new_capacity = initial_capacity + 42;
   this->proxy.reserve(new_capacity);
-  EXPECT_EQ(this->proxy.capacity(), new_capacity);
-  EXPECT_EQ(this->container.capacity(), new_capacity);
+  EXPECT_GE(this->proxy.capacity(), new_capacity);
+  EXPECT_EQ(this->proxy.capacity(), this->container.capacity());
 
+  const int capacity_after_first_reserve = this->proxy.capacity();
   const int lower_capacity = 1;
   this->proxy.reserve(lower_capacity);
-  EXPECT_EQ(this->proxy.capacity(), new_capacity);
-  EXPECT_EQ(this->container.capacity(), new_capacity);
+  EXPECT_EQ(this->proxy.capacity(), capacity_after_first_reserve);
+  EXPECT_EQ(this->container.capacity(), capacity_after_first_reserve);
 }
 
 }  // namespace
diff --git a/verible/verilog/analysis/checkers/BUILD b/verible/verilog/analysis/checkers/BUILD
index bd3a98b..4681607 100644
--- a/verible/verilog/analysis/checkers/BUILD
+++ b/verible/verilog/analysis/checkers/BUILD
@@ -817,6 +817,7 @@
         "//verible/common/analysis:syntax-tree-lint-rule",
         "//verible/common/analysis/matcher",
         "//verible/common/analysis/matcher:bound-symbol-manager",
+        "//verible/common/text:config-utils",
         "//verible/common/text:symbol",
         "//verible/common/text:syntax-tree-context",
         "//verible/common/text:token-info",
@@ -826,7 +827,9 @@
         "//verible/verilog/CST:verilog-nonterminals",
         "//verible/verilog/analysis:descriptions",
         "//verible/verilog/analysis:lint-rule-registry",
+        "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/strings",
+        "@re2",
     ],
     alwayslink = 1,
 )
@@ -1821,6 +1824,7 @@
         "//verible/common/text:symbol",
         "//verible/common/text:syntax-tree-context",
         "//verible/common/text:token-info",
+        "//verible/common/util:container-util",
         "//verible/verilog/CST:port",
         "//verible/verilog/CST:verilog-matchers",
         "//verible/verilog/analysis:descriptions",
diff --git a/verible/verilog/analysis/checkers/generate-label-prefix-rule.cc b/verible/verilog/analysis/checkers/generate-label-prefix-rule.cc
index c8822ce..e678ad5 100644
--- a/verible/verilog/analysis/checkers/generate-label-prefix-rule.cc
+++ b/verible/verilog/analysis/checkers/generate-label-prefix-rule.cc
@@ -14,12 +14,17 @@
 
 #include "verible/verilog/analysis/checkers/generate-label-prefix-rule.h"
 
+#include <memory>
+#include <string>
 #include <string_view>
 
-#include "absl/strings/match.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "re2/re2.h"
 #include "verible/common/analysis/lint-rule-status.h"
 #include "verible/common/analysis/matcher/bound-symbol-manager.h"
 #include "verible/common/analysis/matcher/matcher.h"
+#include "verible/common/text/config-utils.h"
 #include "verible/common/text/symbol.h"
 #include "verible/common/text/syntax-tree-context.h"
 #include "verible/common/text/token-info.h"
@@ -38,22 +43,36 @@
 // Register the lint rule
 VERILOG_REGISTER_LINT_RULE(GenerateLabelPrefixRule);
 
-static constexpr std::string_view kMessage =
-    "All generate block labels must start with g_ or gen_";
+static constexpr std::string_view kDefaultStyleRegex = "(g_|gen_).*";
 
-// TODO(fangism): and be lower_snake_case?
-// TODO(fangism): generalize to a configurable pattern and
-// rename this class/rule to GenerateLabelNamingStyle?
+GenerateLabelPrefixRule::GenerateLabelPrefixRule()
+    : style_regex_(
+          std::make_unique<re2::RE2>(kDefaultStyleRegex, re2::RE2::Quiet)) {}
 
 const LintRuleDescriptor &GenerateLabelPrefixRule::GetDescriptor() {
   static const LintRuleDescriptor d{
       .name = "generate-label-prefix",
       .topic = "generate-constructs",
-      .desc = "Checks that every generate block label starts with g_ or gen_.",
+      .desc =
+          "Checks that every generate block label matches the regex defined by "
+          "style_regex. The default regex requires labels to start with g_ or "
+          "gen_. Refer to https://github.com/chipsalliance/verible/tree/master/"
+          "verilog/tools/lint#readme for more detail on verible regex "
+          "patterns.",
+      // NOLINTNEXTLINE(misc-include-cleaner)
+      .param = {{"style_regex", std::string(kDefaultStyleRegex),
+                 "A regex used to check generate label style."}},
   };
   return d;
 }
 
+std::string GenerateLabelPrefixRule::CreateViolationMessage() const {
+  return absl::StrCat(
+      "Generate block label does not match the naming convention defined by "
+      "regex pattern: ",
+      style_regex_->pattern());
+}
+
 // Matches begin statements
 static const Matcher &BlockMatcher() {
   static const Matcher matcher(NodekGenerateBlock());
@@ -84,15 +103,24 @@
       }
 
       if (label != nullptr) {
-        if (!(absl::StartsWith(label->text(), "g_") ||
-              absl::StartsWith(label->text(), "gen_"))) {
-          violations_.insert(verible::LintViolation(*label, kMessage, context));
+        if (!RE2::FullMatch(label->text(), *style_regex_)) {
+          violations_.insert(verible::LintViolation(
+              *label, CreateViolationMessage(), context));
         }
       }
     }
   }
 }
 
+// NOLINTNEXTLINE(misc-include-cleaner)
+absl::Status GenerateLabelPrefixRule::Configure(
+    std::string_view configuration) {
+  using verible::config::SetRegex;
+  absl::Status s = verible::ParseNameValues(
+      configuration, {{"style_regex", SetRegex(&style_regex_)}});
+  return s;
+}
+
 verible::LintRuleStatus GenerateLabelPrefixRule::Report() const {
   return verible::LintRuleStatus(violations_, GetDescriptor());
 }
diff --git a/verible/verilog/analysis/checkers/generate-label-prefix-rule.h b/verible/verilog/analysis/checkers/generate-label-prefix-rule.h
index 9090cf3..e18df9c 100644
--- a/verible/verilog/analysis/checkers/generate-label-prefix-rule.h
+++ b/verible/verilog/analysis/checkers/generate-label-prefix-rule.h
@@ -15,8 +15,13 @@
 #ifndef VERIBLE_VERILOG_ANALYSIS_CHECKERS_GENERATE_LABEL_PREFIX_RULE_H_
 #define VERIBLE_VERILOG_ANALYSIS_CHECKERS_GENERATE_LABEL_PREFIX_RULE_H_
 
+#include <memory>
 #include <set>
+#include <string>
+#include <string_view>
 
+#include "absl/status/status.h"
+#include "re2/re2.h"
 #include "verible/common/analysis/lint-rule-status.h"
 #include "verible/common/analysis/syntax-tree-lint-rule.h"
 #include "verible/common/text/symbol.h"
@@ -27,20 +32,28 @@
 namespace analysis {
 
 // GenerateLabelPrefixRule checks that all generate block labels start
-// with g_ or gen_
+// with g_ or gen_ (configurable via style_regex)
 class GenerateLabelPrefixRule : public verible::SyntaxTreeLintRule {
  public:
   using rule_type = verible::SyntaxTreeLintRule;
 
+  GenerateLabelPrefixRule();
+
   static const LintRuleDescriptor &GetDescriptor();
 
+  std::string CreateViolationMessage() const;
+
   void HandleSymbol(const verible::Symbol &symbol,
                     const verible::SyntaxTreeContext &context) final;
 
   verible::LintRuleStatus Report() const final;
 
+  absl::Status Configure(std::string_view configuration) final;
+
  private:
   std::set<verible::LintViolation> violations_;
+
+  std::unique_ptr<re2::RE2> style_regex_;
 };
 
 }  // namespace analysis
diff --git a/verible/verilog/analysis/checkers/generate-label-prefix-rule_test.cc b/verible/verilog/analysis/checkers/generate-label-prefix-rule_test.cc
index b46bfe4..cb43501 100644
--- a/verible/verilog/analysis/checkers/generate-label-prefix-rule_test.cc
+++ b/verible/verilog/analysis/checkers/generate-label-prefix-rule_test.cc
@@ -27,6 +27,7 @@
 namespace {
 
 using verible::LintTestCase;
+using verible::RunConfiguredLintTestCases;
 using verible::RunLintTestCases;
 
 TEST(GenerateLabelPrefixRuleTest, Various) {
@@ -229,6 +230,40 @@
   RunLintTestCases<VerilogAnalyzer, GenerateLabelPrefixRule>(kTestCases);
 }
 
+TEST(GenerateLabelPrefixRuleTest, CustomRegex) {
+  const std::initializer_list<LintTestCase> kTestCases = {
+      {"module m;\n"
+       "generate\n"
+       "if (1) begin : my_custom_label\n"
+       "end\n"
+       "endgenerate\nendmodule\n"},
+      {"module m;\n"
+       "generate\n"
+       "for (genvar i=0; i<5; i++) begin : my_custom_label\n"
+       "end\n"
+       "endgenerate\nendmodule\n"},
+  };
+  RunConfiguredLintTestCases<VerilogAnalyzer, GenerateLabelPrefixRule>(
+      kTestCases, "style_regex:my_.*");
+
+  const std::initializer_list<LintTestCase> kFailCases = {
+      {"module m;\n"
+       "generate\n"
+       "if (1) begin : ",
+       {SymbolIdentifier, "g_label"},
+       "\nend\n"
+       "endgenerate\nendmodule\n"},
+      {"module m;\n"
+       "generate\n"
+       "if (1) begin : ",
+       {SymbolIdentifier, "gen_label"},
+       "\nend\n"
+       "endgenerate\nendmodule\n"},
+  };
+  RunConfiguredLintTestCases<VerilogAnalyzer, GenerateLabelPrefixRule>(
+      kFailCases, "style_regex:my_.*");
+}
+
 }  // namespace
 }  // namespace analysis
 }  // namespace verilog
diff --git a/verible/verilog/analysis/checkers/port-name-suffix-rule.cc b/verible/verilog/analysis/checkers/port-name-suffix-rule.cc
index 85a0db3..ffecef3 100644
--- a/verible/verilog/analysis/checkers/port-name-suffix-rule.cc
+++ b/verible/verilog/analysis/checkers/port-name-suffix-rule.cc
@@ -28,6 +28,7 @@
 #include "verible/common/text/symbol.h"
 #include "verible/common/text/syntax-tree-context.h"
 #include "verible/common/text/token-info.h"
+#include "verible/common/util/container-util.h"
 #include "verible/verilog/CST/port.h"
 #include "verible/verilog/CST/verilog-matchers.h"
 #include "verible/verilog/analysis/descriptions.h"
@@ -90,10 +91,16 @@
        {"output", {"o", "no", "po"}},
        {"inout", {"io", "nio", "pio"}}};
 
-  // At this point it is guaranteed that the direction will be set to
-  // one of the expected values (used as keys in the map above).
-  // Therefore checking the suffix like this is safe
-  return suffixes.at(direction).count(suffix) == 1;
+  // `direction` is usually one of the map keys, but the grammar also permits a
+  // `ref` port direction, which has no suffix convention. FindWithDefault looks
+  // the direction up with an empty-set fallback, so an unknown direction (e.g.
+  // `ref`) has no required suffixes and is treated as "correct" (no violation),
+  // consistent with Violation() which also ignores non-input/output/inout
+  // directions.
+  static const std::set<std::string_view> kNoConvention;
+  const std::set<std::string_view> &valid =
+      verible::container::FindWithDefault(suffixes, direction, kNoConvention);
+  return valid.empty() || valid.count(suffix) == 1;
 }
 
 void PortNameSuffixRule::HandleSymbol(const Symbol &symbol,
@@ -113,8 +120,11 @@
         absl::StrSplit(name, '_', absl::SkipEmpty());
 
     if (name_parts.size() < 2) {
-      // No suffix at all
+      // No suffix at all. This also covers an all-underscore name (e.g. "_"),
+      // for which SkipEmpty leaves name_parts empty; return here so the
+      // name_parts.back() access below is not reached on an empty vector.
       Violation(direction, token, context);
+      return;
     }
 
     if (!IsSuffixCorrect(name_parts.back(), direction)) {
diff --git a/verible/verilog/analysis/checkers/port-name-suffix-rule_test.cc b/verible/verilog/analysis/checkers/port-name-suffix-rule_test.cc
index 69f18f4..db69d71 100644
--- a/verible/verilog/analysis/checkers/port-name-suffix-rule_test.cc
+++ b/verible/verilog/analysis/checkers/port-name-suffix-rule_test.cc
@@ -57,6 +57,9 @@
       {"module t (input bit name_i); endmodule;"},
       {"module t (output bit abc_o); endmodule;"},
       {"module t (inout bit xyz_io); endmodule;"},
+      // A `ref` port has no suffix convention and must not be flagged (and must
+      // not crash the rule via std::map::at).
+      {"module t (ref logic data_x); endmodule;"},
       {"module t (input logic name_i,\n"
        "output logic abc_o,\n"
        "inout logic xyz_io,\n"
@@ -90,6 +93,10 @@
       {"module t (output logic ", {kToken, "_o"}, "); endmodule;"},
       {"module t (inout logic ", {kToken, "_io"}, "); endmodule;"},
 
+      // An all-underscore name splits (SkipEmpty) to an empty parts list; it
+      // must report a suffix violation, not dereference an empty vector.
+      {"module t (input logic ", {kToken, "_"}, "); endmodule;"},
+
       {"module t (input logic ", {kToken, "namei"}, "); endmodule;"},
       {"module t (input logic ", {kToken, "nam_ei"}, "); endmodule;"},
       {"module t (input logic ", {kToken, "name_o"}, "); endmodule;"},
diff --git a/verible/verilog/analysis/symbol-table_test.cc b/verible/verilog/analysis/symbol-table_test.cc
index e15ec5f..3e6b1a6 100644
--- a/verible/verilog/analysis/symbol-table_test.cc
+++ b/verible/verilog/analysis/symbol-table_test.cc
@@ -73,8 +73,7 @@
   const auto found_##dest(map.find(key)); /* iterator */ \
   ASSERT_NE(found_##dest, map.end())                     \
       << "No element at \"" << key << "\" in " #map;     \
-  const auto &dest ABSL_ATTRIBUTE_UNUSED(                \
-      found_##dest->second); /* mapped_type */
+  const auto &dest [[maybe_unused]] (found_##dest->second); /* mapped_type */
 
 // Assert that container is not empty, and reference its first element.
 // Works on any container type with .begin().
@@ -103,7 +102,7 @@
       << "No symbol at \"" << key << "\" in " << ScopePathPrinter{scope}; \
   EXPECT_EQ(found_##dest->first, key);                                    \
   const SymbolTableNode &dest(found_##dest->second);                      \
-  const SymbolInfo &dest##_info ABSL_ATTRIBUTE_UNUSED(dest.Value())
+  const SymbolInfo &dest##_info [[maybe_unused]] (dest.Value())
 
 // For SymbolInfo::references_map_view_type only: Assert that there is exactly
 // one element at 'key' in 'map' and assign it to 'dest' (DependentReferences).
diff --git a/verible/verilog/analysis/verilog-equivalence.cc b/verible/verilog/analysis/verilog-equivalence.cc
index f8a47d0..d5c12bea 100644
--- a/verible/verilog/analysis/verilog-equivalence.cc
+++ b/verible/verilog/analysis/verilog-equivalence.cc
@@ -89,6 +89,26 @@
   return IsUnlexed(verilog_tokentype(token.token_enum()));
 }
 
+// True when left/right differ only because surrounding whitespace changed
+// token classification (e.g. MacroCallCloseToEndLine vs ')', or
+// MacroIdentifier vs MacroIdItem with unchanged spelling).
+static bool TokensAreWhitespaceDependentFormatEquivalent(
+    const TokenInfo &left, const TokenInfo &right) {
+  if ((left.token_enum() == verilog_tokentype::MacroCallCloseToEndLine &&
+       right.text() == ")") ||
+      (right.token_enum() == verilog_tokentype::MacroCallCloseToEndLine &&
+       left.text() == ")")) {
+    return true;
+  }
+  const auto is_line_ending_macro = [](int token_enum) {
+    return token_enum == verilog_tokentype::MacroIdentifier ||
+           token_enum == verilog_tokentype::MacroIdItem;
+  };
+  return is_line_ending_macro(left.token_enum()) &&
+         is_line_ending_macro(right.token_enum()) &&
+         left.text() == right.text();
+}
+
 DiffStatus VerilogLexicallyEquivalent(
     std::string_view left, std::string_view right,
     const std::function<bool(const verible::TokenInfo &)> &remove_predicate,
@@ -167,11 +187,11 @@
   DiffStatus diff_status = DiffStatus::kEquivalent;
   auto recursive_comparator = [&](const TokenSequence::const_iterator l,
                                   const TokenSequence::const_iterator r) {
+    // Some token enums differ only by surrounding whitespace (e.g. whether a
+    // macro or ')' ends a line). Treat those pairs as matching enums when the
+    // spelling is unchanged so FormatEquivalent tolerates re-wrapping.
     if (l->token_enum() != r->token_enum() &&
-        !((l->token_enum() == verilog_tokentype::MacroCallCloseToEndLine &&
-           r->text() == ")") ||
-          (r->token_enum() == verilog_tokentype::MacroCallCloseToEndLine &&
-           l->text() == ")"))) {
+        !TokensAreWhitespaceDependentFormatEquivalent(*l, *r)) {
       if (errstream != nullptr) {
         *errstream << "Mismatched token enums.  got: ";
         token_printer(*l, *errstream);
@@ -250,12 +270,7 @@
         return IsWhitespace(verilog_tokentype(t.token_enum()));
       },
       [=](const TokenInfo &l, const TokenInfo &r) {
-        // MacroCallCloseToEndLine should be considered equivalent to ')', as
-        // they are whitespace dependant
-        if (((r.token_enum() == verilog_tokentype::MacroCallCloseToEndLine) &&
-             (l.text() == ")")) ||
-            ((l.token_enum() == verilog_tokentype::MacroCallCloseToEndLine) &&
-             (r.text() == ")"))) {
+        if (TokensAreWhitespaceDependentFormatEquivalent(l, r)) {
           return true;
         }
         return l.EquivalentWithoutLocation(r);
diff --git a/verible/verilog/analysis/verilog-equivalence_test.cc b/verible/verilog/analysis/verilog-equivalence_test.cc
index 90b0ee1..1cb9436 100644
--- a/verible/verilog/analysis/verilog-equivalence_test.cc
+++ b/verible/verilog/analysis/verilog-equivalence_test.cc
@@ -255,6 +255,21 @@
   }
 }
 
+// MacroIdentifier vs MacroIdItem depends on whether the macro ends the line.
+TEST(FormatEquivalentTest, EquivalenceOfMacroIdentifierAndMacroIdItem) {
+  const char *kSameSpelling[] = {
+      "assign x = f(`TOKEN);\n",
+      "assign x = f(\n`TOKEN\n);\n",
+  };
+  ExpectCompareWithErrstream(FormatEquivalent, DiffStatus::kEquivalent,
+                             kSameSpelling[0], kSameSpelling[1]);
+
+  // Different macro names remain different.
+  ExpectCompareWithErrstream(FormatEquivalent, DiffStatus::kDifferent,
+                             "assign x = f(`TOKEN);\n",
+                             "assign x = f(`OTHER);\n");
+}
+
 TEST(FormatEquivalentTest, DiagnosticMismatch) {
   const char *kTestCases[] = {
       "module foo;\n",
diff --git a/verible/verilog/formatting/BUILD b/verible/verilog/formatting/BUILD
index 6150594..eb089df 100644
--- a/verible/verilog/formatting/BUILD
+++ b/verible/verilog/formatting/BUILD
@@ -163,7 +163,6 @@
         "//verible/common/util:expandable-tree-view",
         "//verible/common/util:interval",
         "//verible/common/util:interval-set",
-        "//verible/common/util:iterator-range",
         "//verible/common/util:logging",
         "//verible/common/util:spacer",
         "//verible/common/util:tree-operations",
@@ -175,7 +174,6 @@
         "//verible/verilog/analysis:verilog-equivalence",
         "//verible/verilog/parser:verilog-token-enum",
         "//verible/verilog/preprocessor:verilog-preprocess",
-        "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/log:die_if_null",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
@@ -183,28 +181,91 @@
     ],
 )
 
-cc_test(
-    name = "formatter_test",
-    srcs = ["formatter_test.cc"],
+cc_library(
+    name = "formatter-test-utils",
+    testonly = True,
+    hdrs = ["formatter-test-utils.h"],
     deps = [
         ":format-style",
         ":formatter",
-        "//verible/common/formatting:align",
-        "//verible/common/formatting:basic-format-style",
-        "//verible/common/strings:display-utils",
-        "//verible/common/strings:position",
-        "//verible/common/text:text-structure",
-        "//verible/common/util:interval",
         "//verible/common/util:logging",
-        "//verible/verilog/analysis:verilog-analyzer",
-        "@abseil-cpp//absl/log:die_if_null",
-        "@abseil-cpp//absl/status",
-        "@abseil-cpp//absl/strings",
         "@googletest//:gtest",
-        "@googletest//:gtest_main",
     ],
 )
 
+_FORMATTER_E2E_TEST_DEPS = [
+    ":format-style",
+    ":formatter",
+    ":formatter-test-utils",
+    "//verible/common/formatting:align",
+    "//verible/common/formatting:basic-format-style",
+    "//verible/common/strings:display-utils",
+    "//verible/common/strings:position",
+    "//verible/common/text:text-structure",
+    "//verible/common/util:interval",
+    "//verible/common/util:logging",
+    "//verible/verilog/analysis:verilog-analyzer",
+    "@abseil-cpp//absl/log:die_if_null",
+    "@abseil-cpp//absl/status",
+    "@abseil-cpp//absl/strings",
+    "@googletest//:gtest",
+    "@googletest//:gtest_main",
+]
+
+cc_test(
+    name = "formatter_test",
+    srcs = ["formatter_test.cc"],
+    deps = _FORMATTER_E2E_TEST_DEPS,
+)
+
+cc_test(
+    name = "formatter_macro_test",
+    srcs = ["formatter_macro_test.cc"],
+    deps = _FORMATTER_E2E_TEST_DEPS,
+)
+
+cc_test(
+    name = "formatter_module_test",
+    srcs = ["formatter_module_test.cc"],
+    deps = _FORMATTER_E2E_TEST_DEPS,
+)
+
+cc_test(
+    name = "formatter_class_package_test",
+    srcs = ["formatter_class_package_test.cc"],
+    deps = _FORMATTER_E2E_TEST_DEPS,
+)
+
+cc_test(
+    name = "formatter_function_task_test",
+    srcs = ["formatter_function_task_test.cc"],
+    deps = _FORMATTER_E2E_TEST_DEPS,
+)
+
+cc_test(
+    name = "formatter_align_test",
+    srcs = ["formatter_align_test.cc"],
+    deps = _FORMATTER_E2E_TEST_DEPS,
+)
+
+cc_test(
+    name = "formatter_wrap_style_test",
+    srcs = ["formatter_wrap_style_test.cc"],
+    deps = _FORMATTER_E2E_TEST_DEPS,
+)
+
+cc_test(
+    name = "formatter_disable_test",
+    srcs = ["formatter_disable_test.cc"],
+    deps = _FORMATTER_E2E_TEST_DEPS,
+)
+
+cc_test(
+    name = "formatter_issue_regression_test",
+    srcs = ["formatter_issue_regression_test.cc"],
+    deps = _FORMATTER_E2E_TEST_DEPS,
+)
+
 cc_test(
     name = "formatter-tuning_test",
     srcs = ["formatter-tuning_test.cc"],
diff --git a/verible/verilog/formatting/README.md b/verible/verilog/formatting/README.md
index 6f815bf..03b6f5e 100644
--- a/verible/verilog/formatting/README.md
+++ b/verible/verilog/formatting/README.md
@@ -16,7 +16,23 @@
 Below is a quick summary of the major components.
 
 [formatter.h](formatter.h) contains the top-level entry point into the
-formatter. Text-in-text-out tests are in [formatter_test.cc](formatter_test.cc).
+formatter. Text-in-text-out tests are split by concern to reduce merge
+conflicts:
+
+- [formatter_test.cc](formatter_test.cc) — core smoke / `VerifyFormatting`
+- [formatter_macro_test.cc](formatter_macro_test.cc) — preprocessor, `` `uvm ``, directives
+- [formatter_module_test.cc](formatter_module_test.cc) — modules, ports, nets, expressions
+- [formatter_class_package_test.cc](formatter_class_package_test.cc) — classes, packages, constraints
+- [formatter_function_task_test.cc](formatter_function_task_test.cc) — functions, tasks, properties
+- [formatter_align_test.cc](formatter_align_test.cc) — tabular / param alignment
+- [formatter_wrap_style_test.cc](formatter_wrap_style_test.cc) — wrap/indent options, diagnostics
+- [formatter_disable_test.cc](formatter_disable_test.cc) — `verilog_format` on/off
+- [formatter_issue_regression_test.cc](formatter_issue_regression_test.cc) — GitHub issue regressions
+- Shared helpers: [formatter-test-utils.h](formatter-test-utils.h)
+
+**New GitHub-issue formatter regressions belong in
+`formatter_issue_regression_test.cc` only** (do not append them to
+`formatter_test.cc`).
 
 [FormatStyle](format_style.h) defines ways in which formatting can be
 configured.
diff --git a/verible/verilog/formatting/format-style-init.cc b/verible/verilog/formatting/format-style-init.cc
index 2dde818..a6d010b 100644
--- a/verible/verilog/formatting/format-style-init.cc
+++ b/verible/verilog/formatting/format-style-init.cc
@@ -140,6 +140,13 @@
           "Use compact binary expressions inside indexing / bit selection "
           "operators");
 
+ABSL_FLAG(bool, class_parameter_space, false,
+          "If true, keep/insert a space before '#' in a class"
+          "parameterized typedef, e.g. \"typedef my_class #(.P(P)) "
+          "my_class_t;\".  If false (default), no space is inserted, "
+          "matching the convention used for IEEE parameterized class "
+          "instantiations, e.g. \"type#(params...)::method(...)\".");
+
 ABSL_FLAG(bool, wrap_end_else_clauses, false,
           "Split end and else keywords into separate lines");
 
@@ -197,6 +204,7 @@
   STYLE_FROM_FLAG(try_wrap_long_lines);
   STYLE_FROM_FLAG(expand_coverpoints);
   STYLE_FROM_FLAG(compact_indexing_and_selections);
+  STYLE_FROM_FLAG(class_parameter_space);
   STYLE_FROM_FLAG(wrap_end_else_clauses);
   STYLE_FROM_FLAG(alignment_group_boundary);
 
diff --git a/verible/verilog/formatting/format-style.h b/verible/verilog/formatting/format-style.h
index 2fad329..55347c5 100644
--- a/verible/verilog/formatting/format-style.h
+++ b/verible/verilog/formatting/format-style.h
@@ -146,6 +146,9 @@
   // Compact binary expressions inside indexing / bit selection operators
   bool compact_indexing_and_selections = true;
 
+  // Keep/insert a space before '#' in a parameterized class typedef
+  bool class_parameter_space = false;
+
   // Split with a \n end and else clauses
   bool wrap_end_else_clauses = false;
 
diff --git a/verible/verilog/formatting/formatter-test-utils.h b/verible/verilog/formatting/formatter-test-utils.h
new file mode 100644
index 0000000..0be6382
--- /dev/null
+++ b/verible/verilog/formatting/formatter-test-utils.h
@@ -0,0 +1,69 @@
+// Copyright 2017-2026 The Verible Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Shared helpers for formatter end-to-end tests.
+// Penalty-sensitive cases belong in formatter-tuning_test.cc.
+
+#ifndef VERIBLE_VERILOG_FORMATTING_FORMATTER_TEST_UTILS_H_
+#define VERIBLE_VERILOG_FORMATTING_FORMATTER_TEST_UTILS_H_
+
+#include <sstream>
+#include <string_view>
+
+#include "gtest/gtest.h"
+#include "verible/common/util/logging.h"
+#include "verible/verilog/formatting/format-style.h"
+#include "verible/verilog/formatting/formatter.h"
+
+#undef EXPECT_OK
+#define EXPECT_OK(value) EXPECT_TRUE((value).ok())
+
+#undef ASSERT_OK
+#define ASSERT_OK(value) ASSERT_TRUE((value).ok())
+
+namespace verilog {
+namespace formatter {
+
+struct FormatterTestCase {
+  std::string_view input;
+  std::string_view expected;
+};
+
+// Runs FormatVerilog on each case and checks status + exact expected output.
+template <typename CaseRange>
+void RunFormatterTestCases(const FormatStyle &style, const CaseRange &cases) {
+  for (const auto &test_case : cases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Convenience: column_limit 40 / indent 2 / wrap 4 — the default E2E style.
+template <typename CaseRange>
+void RunFormatterTestCases40(const CaseRange &cases) {
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  RunFormatterTestCases(style, cases);
+}
+
+}  // namespace formatter
+}  // namespace verilog
+
+#endif  // VERIBLE_VERILOG_FORMATTING_FORMATTER_TEST_UTILS_H_
diff --git a/verible/verilog/formatting/formatter.cc b/verible/verilog/formatting/formatter.cc
index 9893b60..9bd3dd2 100644
--- a/verible/verilog/formatting/formatter.cc
+++ b/verible/verilog/formatting/formatter.cc
@@ -26,7 +26,6 @@
 #include <string_view>
 #include <vector>
 
-#include "absl/base/attributes.h"
 #include "absl/log/die_if_null.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -50,7 +49,6 @@
 #include "verible/common/util/expandable-tree-view.h"
 #include "verible/common/util/interval-set.h"
 #include "verible/common/util/interval.h"
-#include "verible/common/util/iterator-range.h"
 #include "verible/common/util/logging.h"
 #include "verible/common/util/spacer.h"
 #include "verible/common/util/tree-operations.h"
@@ -749,15 +747,24 @@
       case verible::SpacingDecision::kPreserve: {
         if (token.before.preserved_space_start !=
             verible::string_view_null_iterator()) {
-          *column += token.OriginalLeadingSpaces().length();
+          const std::string_view leading = token.OriginalLeadingSpaces();
+          const auto last_nl = leading.find_last_of('\n');
+          if (last_nl == std::string_view::npos) {
+            *column += leading.length();
+          } else {
+            // Reset column after the last newline, same as FormattedToken
+            // emit (GitHub issue 2542).
+            *column = static_cast<int>(leading.length() - last_nl - 1);
+          }
         } else {
           *column += token.before.spaces;
         }
         break;
       }
       case verible::SpacingDecision::kWrap:
-        *column = 0;
-        ABSL_FALLTHROUGH_INTENDED;
+        // Newline then only the wrap indent (same as FormattedToken emit).
+        *column = token.before.spaces;
+        break;
       case verible::SpacingDecision::kAlign:
       case verible::SpacingDecision::kAppend:
         *column += token.before.spaces;
@@ -766,6 +773,15 @@
   }
 
   static int CalculateEolCommentColumn(const verible::FormattedExcerpt &line) {
+    // Compute the starting column of the trailing EOL comment the same way
+    // FormattedExcerpt::FormattedText emits spaces, including:
+    //   * wrap indents (SpacingDecision::kWrap), and
+    //   * preserved leading whitespace that may contain newlines (common when
+    //     an original line break is kept). Counting those newlines as width
+    //     made continuation comments land on the wrong column and fail to
+    //     converge on re-format (GitHub issue 2542).
+    if (line.Tokens().empty()) return 0;
+
     int column = 0;
     const auto &front = line.Tokens().front();
 
@@ -777,12 +793,16 @@
     }
     column += front.token->text().length();
 
-    for (const auto &ftoken : verible::make_range(line.Tokens().begin() + 1,
-                                                  line.Tokens().end() - 1)) {
+    const auto &tokens = line.Tokens();
+    for (size_t i = 1; i < tokens.size(); ++i) {
+      const auto &ftoken = tokens[i];
       AdjustColumnUsingTokenSpacing(ftoken, &column);
-      column += ftoken.token->text().length();
+      // Do not add the last token's length: that is the EOL comment whose
+      // starting column we want.
+      if (i + 1 < tokens.size()) {
+        column += ftoken.token->text().length();
+      }
     }
-    AdjustColumnUsingTokenSpacing(line.Tokens().back(), &column);
 
     CHECK_GE(column, 0);
     return column;
diff --git a/verible/verilog/formatting/formatter_align_test.cc b/verible/verilog/formatting/formatter_align_test.cc
new file mode 100644
index 0000000..affb5a7
--- /dev/null
+++ b/verible/verilog/formatting/formatter_align_test.cc
@@ -0,0 +1,5066 @@
+// Copyright 2017-2026 The Verible Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Test cases in this file should be *insensitive* to wrapping penalties.
+// Penalty-sensitive tests belong in formatter-tuning_test.cc.
+
+#include <sstream>
+#include <string_view>
+
+#include "gtest/gtest.h"
+#include "verible/common/formatting/align.h"
+#include "verible/common/util/logging.h"
+#include "verible/verilog/formatting/format-style.h"
+#include "verible/verilog/formatting/formatter-test-utils.h"
+#include "verible/verilog/formatting/formatter.h"
+
+namespace verilog {
+namespace formatter {
+namespace {
+
+using verible::AlignmentPolicy;
+
+static constexpr FormatterTestCase kAlignFormatterTestCases[] = {
+    // module instantiation named ports tabular alignment
+    //{// module instantiation with no port, only comments
+    //    "module m;\n"
+    //    "foo bar(\n"
+    //    "\t//comment1\n"
+    //    "//comment2\n"
+    //    ");\n"
+    //    "endmodule\n",
+    //    "module m;\n"
+    //    "  foo bar (\n"
+    //    "      //comment1\n"
+    //    "      //comment2\n"
+    //    "  );\n"
+    //    "endmodule\n"
+    //},
+    {// all named ports
+     "module m;\n"
+     "foo bar(.a(a), .aa(aa), .aaa(aaa));\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),\n"
+     "      .aa (aa),\n"
+     "      .aaa(aaa)\n"
+     "  );\n"
+     "endmodule\n"},
+    {// named ports left unconnected
+     "module m;\n"
+     "foo bar(.a(), .aa(), .aaa());\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (),\n"
+     "      .aa (),\n"
+     "      .aaa()\n"
+     "  );\n"
+     "endmodule\n"},
+    {// multiple named ports groups separated by blank line
+     "module m;\n"
+     "foo bar(.a(a), .aaa(aaa),\n\n .b(b), .bbbbbb(bbbbb));\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),\n"
+     "      .aaa(aaa),\n"
+     "\n"
+     "      .b     (b),\n"
+     "      .bbbbbb(bbbbb)\n"
+     "  );\n"
+     "endmodule\n"},
+    {// named ports with concatenation
+     "module m;\n"
+     "foo bar(.a(a), .aaa({a,b,c}));\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),\n"
+     "      .aaa({a, b, c})\n"
+     "  );\n"
+     "endmodule\n"},
+    {// name ports with slices
+     "module m;\n"
+     "foo bar(.a(a), .aaa(q[r:s]));\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),\n"
+     "      .aaa(q[r:s])\n"
+     "  );\n"
+     "endmodule\n"},
+    {// named ports with pre-proc directives
+     "module m;\n"
+     "foo bar(.a(a), `ifdef MACRO .aa(aa), `endif .aaa(aaa));\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),\n"
+     "`ifdef MACRO\n"
+     "      .aa (aa),\n"
+     "`endif\n"
+     "      .aaa(aaa)\n"
+     "  );\n"
+     "endmodule\n"},
+    {// named ports with macros
+     "module m;\n"
+     "foo bar(.a(a), .aa(aa[`RANGE]), .aaa(aaa));\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),\n"
+     "      .aa (aa[`RANGE]),\n"
+     "      .aaa(aaa)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "foo bar(.a(a), .AA, .aaa(aaa));\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),\n"
+     "      .AA,\n"
+     "      .aaa(aaa)\n"
+     "  );\n"
+     "endmodule\n"},
+    {// name ports with comments
+     "module m;\n"
+     "foo bar(.a(a), .aa(aa)/*comment*/, .aaa(aaa));\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),\n"
+     "      .aa (aa)  /*comment*/,\n"
+     "      .aaa(aaa)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "foo bar(.a(a),//comment1\n .aaa(aaa)//comment2\n);\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),   //comment1\n"
+     "      .aaa(aaa)  //comment2\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "foo bar(.a(a),\n"
+     " //.aa(aa),\n"
+     ".aaa(aaa));\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),\n"
+     "      //.aa(aa),\n"
+     "      .aaa(aaa)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "foo bar(\n"
+     ".a(a) //comment1\n"
+     ", .aaa(aaa) //comment2\n"
+     ") //comment3\n"
+     ";\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "        .a  (a)    //comment1\n"
+     "      , .aaa(aaa)  //comment2\n"
+     "  )  //comment3\n"
+     "  ;\n"
+     "endmodule\n"},
+    {// module instantiation with all implicit connections
+     "module m;\n"
+     "foo bar(.a, .aa, .aaaaa);\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a,\n"
+     "      .aa,\n"
+     "      .aaaaa\n"
+     "  );\n"
+     "endmodule\n"},
+    {// named ports corssed with implicit connections
+     "module m;\n"
+     "foo bar(.a(a), .aa, .aaaaa(aaaaa));\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a    (a),\n"
+     "      .aa,\n"
+     "      .aaaaa(aaaaa)\n"
+     "  );\n"
+     "endmodule\n"},
+    {// named ports corssed with wildcard connections
+     "module m;\n"
+     "foo bar(.a(a), .aaa(aaa), .*);\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),\n"
+     "      .aaa(aaa),\n"
+     "      .*\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "foo bar(.a(a), .aa(aa), .* , .aaa(aaa));\n"
+     "endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a  (a),\n"
+     "      .aa (aa),\n"
+     "      .*,\n"
+     "      .aaa(aaa)\n"
+     "  );\n"
+     "endmodule\n"},
+
+    // Parameterized data types, declarations inside #() tabular alignment
+    {// parameterized module with 'list_of_param_assignments'
+     "module foo #(A = 2, AA = 22, AAA = 222);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    A   = 2,\n"
+     "    AA  = 22,\n"
+     "    AAA = 222\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'parameter_declaration'
+     "module foo #(parameter int a = 2, parameter int aa = 22);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    parameter int a  = 2,\n"
+     "    parameter int aa = 22\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'parameter_declaration' and comments
+     "module foo #(//comment\nparameter int a = 2, parameter int aa = 22);\n"
+     "endmodule\n",
+     "module foo #(  //comment\n"
+     "    parameter int a  = 2,\n"
+     "    parameter int aa = 22\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'parameter_declaration' and trailing comments
+     "module foo #(parameter int a = 2,//comment\n parameter int aa = 22);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    parameter int a  = 2,  //comment\n"
+     "    parameter int aa = 22\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'parameter_declaration' and pre-proc
+     "module foo #(parameter int a = 2,\n"
+     "`ifdef MACRO parameter int aa = 22, `endif\n"
+     "parameter int aaa = 222);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    parameter int a   = 2,\n"
+     "`ifdef MACRO\n"
+     "    parameter int aa  = 22,\n"
+     "`endif\n"
+     "    parameter int aaa = 222\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'parameter_declaration' and packed dimensions
+     "module foo #(parameter logic [3:0] a = 2, parameter logic [30:0] aa = "
+     "22);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    parameter logic [ 3:0] a  = 2,\n"
+     "    parameter logic [30:0] aa = 22\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'parameter_declaration' and unpacked
+     // dimensions
+     "module foo #(parameter logic a[3:0] = 2, parameter logic  aa [30:0] = "
+     "22);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    parameter logic a [ 3:0] = 2,\n"
+     "    parameter logic aa[30:0] = 22\n"
+     ");\n"
+     "endmodule\n"},
+
+    {// parameterized module with 'local_parameter_declaration'
+     "module foo #(localparam int a = 2, localparam int aa = 22);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    localparam int a  = 2,\n"
+     "    localparam int aa = 22\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'local_parameter_declaration' and comments
+     "module foo #(//comment\nlocalparam int a = 2, localparam int aa = 22);\n"
+     "endmodule\n",
+     "module foo #(  //comment\n"
+     "    localparam int a  = 2,\n"
+     "    localparam int aa = 22\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'local_parameter_declaration' and trailing
+     // comments
+     "module foo #(localparam int a = 2,//comment\n localparam int aa = 22);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    localparam int a  = 2,  //comment\n"
+     "    localparam int aa = 22\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'local_parameter_declaration' and pre-proc
+     "module foo #(localparam int a = 2,\n"
+     "`ifdef MACRO localparam int aa = 22, `endif\n"
+     "localparam int aaa = 222);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    localparam int a   = 2,\n"
+     "`ifdef MACRO\n"
+     "    localparam int aa  = 22,\n"
+     "`endif\n"
+     "    localparam int aaa = 222\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'local_parameter_declaration' and packed
+     // dimensions
+     "module foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa = "
+     "22);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    localparam logic [ 3:0] a  = 2,\n"
+     "    localparam logic [30:0] aa = 22\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'local_parameter_declaration' and unpacked
+     // dimensions
+     "module foo #(localparam logic a[3:0] = 2, localparam logic  aa [30:0] = "
+     "22);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    localparam logic a [ 3:0] = 2,\n"
+     "    localparam logic aa[30:0] = 22\n"
+     ");\n"
+     "endmodule\n"},
+
+    {// parameterized module with 'data_type list_of_param_assignments'
+     "module foo #( int a = 2,  real aa = 22, longint aaa = 222);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    int     a   = 2,\n"
+     "    real    aa  = 22,\n"
+     "    longint aaa = 222\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'data_type list_of_param_assignments' and
+     // comments
+     "module foo #(//comment\nint a = 2,  shortreal aa = 22, longint aaa = "
+     "222);\n"
+     "endmodule\n",
+     "module foo #(  //comment\n"
+     "    int       a   = 2,\n"
+     "    shortreal aa  = 22,\n"
+     "    longint   aaa = 222\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'data_type list_of_param_assignments' and
+     // trailing comments
+     "module foo #(int a = 2,  shortreal aa = 22,//comment\n longint aaa = "
+     "222);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    int       a   = 2,\n"
+     "    shortreal aa  = 22,  //comment\n"
+     "    longint   aaa = 222\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'data_type list_of_param_assignments' and
+     // pre-proc
+     "module foo #(int a = 2,\n"
+     "`ifdef MACRO shortreal aa = 22, `endif\n"
+     " longint aaa = 222);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    int       a   = 2,\n"
+     "`ifdef MACRO\n"
+     "    shortreal aa  = 22,\n"
+     "`endif\n"
+     "    longint   aaa = 222\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'data_type list_of_param_assignments' and
+     // packed dimensions
+     "module foo #(bit [1:0] a = 2,  reg [12:0] aa = 22, logic [123:0] aaa = "
+     "222);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    bit   [  1:0] a   = 2,\n"
+     "    reg   [ 12:0] aa  = 22,\n"
+     "    logic [123:0] aaa = 222\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'data_type list_of_param_assignments' and
+     // unpacked dimensions
+     "module foo #(bit  a[1:0] = 2,  reg  aa[12:0] = 22, logic aaa [123:0]  = "
+     "222);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    bit   a  [  1:0] = 2,\n"
+     "    reg   aa [ 12:0] = 22,\n"
+     "    logic aaa[123:0] = 222\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'type list_of_type_assignments'
+     "module foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    type T   = int,\n"
+     "    type TT  = bit,\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'type list_of_type_assignments' and comments
+     "module foo #(//comment\ntype T = int, type TT = bit, type TTT= C#(logic) "
+     ");\n"
+     "endmodule\n",
+     "module foo #(  //comment\n"
+     "    type T   = int,\n"
+     "    type TT  = bit,\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'data_type list_of_param_assignments' and
+     // trailing comments
+     "module foo #(type T = int, type TT = bit, //comment\n type TTT= "
+     "C#(logic) );\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    type T   = int,\n"
+     "    type TT  = bit,       //comment\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'data_type list_of_param_assignments' and
+     // pre-proc
+     "module foo #(type T = int,\n"
+     "`ifdef MACRO type TT = bit, `endif\n"
+     " type TTT= C#(logic));\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    type T   = int,\n"
+     "`ifdef MACRO\n"
+     "    type TT  = bit,\n"
+     "`endif\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'data_type list_of_param_assignments' and
+     // packed dimensions
+     "module foo #(type T = int [3:0], type TT = bit [250:0]);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    type T  = int [  3:0],\n"
+     "    type TT = bit [250:0]\n"
+     ");\n"
+     "endmodule\n"},
+    {"module foo #(type T = int, "
+     "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, "
+     "localparam AAAAA = 22222, localparam real AAAAAA = 222222"
+     ");\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "               type    T      = int,\n"
+     "                       A      = 2,\n"
+     "               int     AA     = 22,\n"
+     "    parameter          AAA    = 222,\n"
+     "    parameter  longint AAAA   = 2222,\n"
+     "    localparam         AAAAA  = 22222,\n"
+     "    localparam real    AAAAAA = 222222\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with built-in data type
+     "module foo #(int a = 2, real abc = 2234);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    int  a   = 2,\n"
+     "    real abc = 2234\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with type
+     "module foo #(type TYPE1 = int, type TYPE2 = boo);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    type TYPE1 = int,\n"
+     "    type TYPE2 = boo\n"
+     ");\n"
+     "endmodule\n"},
+    {"module foo#(localparam type TYPE1 = int, type TYPE22 = bool, parameter   "
+     " type TYPE333 = real);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    localparam type TYPE1   = int,\n"
+     "               type TYPE22  = bool,\n"
+     "    parameter  type TYPE333 = real\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'data_type list_of_param_assignments' and 1D
+     // packed dimensions
+     "module foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    parameter type T  = int [  3:0],\n"
+     "              type TT = bit [123:0]\n"
+     ");\n"
+     "endmodule\n"},
+    {// parameterized module with 'data_type list_of_param_assignments' and 2D
+     // packed dimensions
+     "module foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    type T  = int [  3:0][123:0],\n"
+     "    type TT = bit [123:0][  1:0]\n"
+     ");\n"
+     "endmodule\n"},
+    {// parametrized module with user defined data types
+     "module foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    type T  = my_type1_t,\n"
+     "    type TT = my_pkg::my_type2_t\n"
+     ");\n"
+     "endmodule\n"},
+
+    {// parameterized class with 'list_of_param_assignments'
+     "class foo #(A = 2, AA = 22, AAA = 222);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    A   = 2,\n"
+     "    AA  = 22,\n"
+     "    AAA = 222\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'parameter_declaration'
+     "class foo #(parameter int a = 2, parameter int aa = 22);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    parameter int a  = 2,\n"
+     "    parameter int aa = 22\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'parameter_declaration' and comments
+     "class foo #(//comment\nparameter int a = 2, parameter int aa = 22);\n"
+     "endclass\n",
+     "class foo #(  //comment\n"
+     "    parameter int a  = 2,\n"
+     "    parameter int aa = 22\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'parameter_declaration' and trailing comments
+     "class foo #(parameter int a = 2,//comment\n parameter int aa = 22);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    parameter int a  = 2,  //comment\n"
+     "    parameter int aa = 22\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'parameter_declaration' and pre-proc
+     "class foo #(parameter int a = 2,\n"
+     "`ifdef MACRO parameter int aa = 22, `endif\n"
+     "parameter int aaa = 222);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    parameter int a   = 2,\n"
+     "`ifdef MACRO\n"
+     "    parameter int aa  = 22,\n"
+     "`endif\n"
+     "    parameter int aaa = 222\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'parameter_declaration' and packed dimensions
+     "class foo #(parameter logic [3:0] a = 2, parameter logic [30:0] aa = "
+     "22);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    parameter logic [ 3:0] a  = 2,\n"
+     "    parameter logic [30:0] aa = 22\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'parameter_declaration' and unpacked dimensions
+     "class foo #(parameter logic a[3:0] = 2, parameter logic  aa [30:0] = "
+     "22);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    parameter logic a [ 3:0] = 2,\n"
+     "    parameter logic aa[30:0] = 22\n"
+     ");\n"
+     "endclass\n"},
+
+    {// parameterized class with 'local_parameter_declaration'
+     "class foo #(localparam int a = 2, localparam int aa = 22);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    localparam int a  = 2,\n"
+     "    localparam int aa = 22\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'local_parameter_declaration' and comments
+     "class foo #(//comment\nlocalparam int a = 2, localparam int aa = 22);\n"
+     "endclass\n",
+     "class foo #(  //comment\n"
+     "    localparam int a  = 2,\n"
+     "    localparam int aa = 22\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'local_parameter_declaration' and trailing
+     // comments
+     "class foo #(localparam int a = 2,//comment\n localparam int aa = 22);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    localparam int a  = 2,  //comment\n"
+     "    localparam int aa = 22\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'local_parameter_declaration' and pre-proc
+     "class foo #(localparam int a = 2,\n"
+     "`ifdef MACRO localparam int aa = 22, `endif\n"
+     "localparam int aaa = 222);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    localparam int a   = 2,\n"
+     "`ifdef MACRO\n"
+     "    localparam int aa  = 22,\n"
+     "`endif\n"
+     "    localparam int aaa = 222\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'local_parameter_declaration' and packed
+     // dimensions
+     "class foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa = "
+     "22);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    localparam logic [ 3:0] a  = 2,\n"
+     "    localparam logic [30:0] aa = 22\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'local_parameter_declaration' and unpacked
+     // dimensions
+     "class foo #(localparam logic a[3:0] = 2, localparam logic  aa [30:0] = "
+     "22);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    localparam logic a [ 3:0] = 2,\n"
+     "    localparam logic aa[30:0] = 22\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'data_type list_of_param_assignments'
+     "class foo #( int a = 2,  real aa = 22, longint aaa = 222);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    int     a   = 2,\n"
+     "    real    aa  = 22,\n"
+     "    longint aaa = 222\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'data_type list_of_param_assignments' and
+     // comments
+     "class foo #(//comment\nint a = 2,  shortreal aa = 22, longint aaa = "
+     "222);\n"
+     "endclass\n",
+     "class foo #(  //comment\n"
+     "    int       a   = 2,\n"
+     "    shortreal aa  = 22,\n"
+     "    longint   aaa = 222\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'data_type list_of_param_assignments' and
+     // trailing comments
+     "class foo #(int a = 2,  shortreal aa = 22,//comment\n longint aaa = "
+     "222);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    int       a   = 2,\n"
+     "    shortreal aa  = 22,  //comment\n"
+     "    longint   aaa = 222\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'data_type list_of_param_assignments' and
+     // pre-proc
+     "class foo #(int a = 2,\n"
+     "`ifdef MACRO shortreal aa = 22, `endif\n"
+     " longint aaa = 222);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    int       a   = 2,\n"
+     "`ifdef MACRO\n"
+     "    shortreal aa  = 22,\n"
+     "`endif\n"
+     "    longint   aaa = 222\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'data_type list_of_param_assignments' and
+     // packed dimensions
+     "class foo #(bit [1:0] a = 2,  reg [12:0] aa = 22, logic [123:0] aaa = "
+     "222);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    bit   [  1:0] a   = 2,\n"
+     "    reg   [ 12:0] aa  = 22,\n"
+     "    logic [123:0] aaa = 222\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'data_type list_of_param_assignments' and
+     // unpacked dimensions
+     "class foo #(bit  a[1:0] = 2,  reg  aa[12:0] = 22, logic aaa [123:0]  = "
+     "222);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    bit   a  [  1:0] = 2,\n"
+     "    reg   aa [ 12:0] = 22,\n"
+     "    logic aaa[123:0] = 222\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'type list_of_type_assignments'
+     "class foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    type T   = int,\n"
+     "    type TT  = bit,\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'type list_of_type_assignments' and comments
+     "class foo #(//comment\ntype T = int, type TT = bit, type TTT= C#(logic) "
+     ");\n"
+     "endclass\n",
+     "class foo #(  //comment\n"
+     "    type T   = int,\n"
+     "    type TT  = bit,\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'data_type list_of_param_assignments' and
+     // trailing comments
+     "class foo #(type T = int, type TT = bit, //comment\n type TTT= C#(logic) "
+     ");\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    type T   = int,\n"
+     "    type TT  = bit,       //comment\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'data_type list_of_param_assignments' and
+     // pre-proc
+     "class foo #(type T = int,\n"
+     "`ifdef MACRO type TT = bit, `endif\n"
+     " type TTT= C#(logic));\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    type T   = int,\n"
+     "`ifdef MACRO\n"
+     "    type TT  = bit,\n"
+     "`endif\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'data_type list_of_param_assignments' and
+     // packed dimensions
+     "class foo #(type T = int [3:0], type TT = bit [250:0]);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    type T  = int [  3:0],\n"
+     "    type TT = bit [250:0]\n"
+     ");\n"
+     "endclass\n"},
+    {"class foo #(type T = int, "
+     "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, "
+     "localparam AAAAA = 22222, localparam real AAAAAA = 222222"
+     ");\n"
+     "endclass\n",
+     "class foo #(\n"
+     "               type    T      = int,\n"
+     "                       A      = 2,\n"
+     "               int     AA     = 22,\n"
+     "    parameter          AAA    = 222,\n"
+     "    parameter  longint AAAA   = 2222,\n"
+     "    localparam         AAAAA  = 22222,\n"
+     "    localparam real    AAAAAA = 222222\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with built-in data type
+     "class foo #(int a = 2, real abc = 2234);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    int  a   = 2,\n"
+     "    real abc = 2234\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with type
+     "class foo #(type TYPE1 = int, type TYPE2 = boo);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    type TYPE1 = int,\n"
+     "    type TYPE2 = boo\n"
+     ");\n"
+     "endclass\n"},
+    {"class foo#(localparam type TYPE1 = int, type TYPE22 = bool, parameter    "
+     "type TYPE333 = real);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    localparam type TYPE1   = int,\n"
+     "               type TYPE22  = bool,\n"
+     "    parameter  type TYPE333 = real\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'data_type list_of_param_assignments' and 1D
+     // packed dimensions
+     "class foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    parameter type T  = int [  3:0],\n"
+     "              type TT = bit [123:0]\n"
+     ");\n"
+     "endclass\n"},
+    {// parameterized class with 'data_type list_of_param_assignments' and 2D
+     // packed dimensions
+     "class foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    type T  = int [  3:0][123:0],\n"
+     "    type TT = bit [123:0][  1:0]\n"
+     ");\n"
+     "endclass\n"},
+    {// parametrized class with user defined data types
+     "class foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n"
+     "endclass\n",
+     "class foo #(\n"
+     "    type T  = my_type1_t,\n"
+     "    type TT = my_pkg::my_type2_t\n"
+     ");\n"
+     "endclass\n"},
+
+    {// parameterized interface with 'local_parameter_declaration'
+     "interface foo #(localparam int a = 2, localparam int aa = 22);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    localparam int a  = 2,\n"
+     "    localparam int aa = 22\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'local_parameter_declaration' and comments
+     "interface foo #(//comment\nlocalparam int a = 2, localparam int aa = "
+     "22);\n"
+     "endinterface\n",
+     "interface foo #(  //comment\n"
+     "    localparam int a  = 2,\n"
+     "    localparam int aa = 22\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'local_parameter_declaration' and trailing
+     // comments
+     "interface foo #(localparam int a = 2,//comment\n localparam int aa = "
+     "22);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    localparam int a  = 2,  //comment\n"
+     "    localparam int aa = 22\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'local_parameter_declaration' and pre-proc
+     "interface foo #(localparam int a = 2,\n"
+     "`ifdef MACRO localparam int aa = 22, `endif\n"
+     "localparam int aaa = 222);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    localparam int a   = 2,\n"
+     "`ifdef MACRO\n"
+     "    localparam int aa  = 22,\n"
+     "`endif\n"
+     "    localparam int aaa = 222\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'local_parameter_declaration' and packed
+     // dimensions
+     "interface foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa "
+     "= 22);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    localparam logic [ 3:0] a  = 2,\n"
+     "    localparam logic [30:0] aa = 22\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'local_parameter_declaration' and unpacked
+     // dimensions
+     "interface foo #(localparam logic a[3:0] = 2, localparam logic  aa [30:0] "
+     "= 22);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    localparam logic a [ 3:0] = 2,\n"
+     "    localparam logic aa[30:0] = 22\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'data_type list_of_param_assignments'
+     "interface foo #( int a = 2,  real aa = 22, longint aaa = 222);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    int     a   = 2,\n"
+     "    real    aa  = 22,\n"
+     "    longint aaa = 222\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'data_type list_of_param_assignments' and
+     // comments
+     "interface foo #(//comment\nint a = 2,  shortreal aa = 22, longint aaa = "
+     "222);\n"
+     "endinterface\n",
+     "interface foo #(  //comment\n"
+     "    int       a   = 2,\n"
+     "    shortreal aa  = 22,\n"
+     "    longint   aaa = 222\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'data_type list_of_param_assignments' and
+     // trailing comments
+     "interface foo #(int a = 2,  shortreal aa = 22,//comment\n longint aaa = "
+     "222);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    int       a   = 2,\n"
+     "    shortreal aa  = 22,  //comment\n"
+     "    longint   aaa = 222\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'data_type list_of_param_assignments' and
+     // pre-proc
+     "interface foo #(int a = 2,\n"
+     "`ifdef MACRO shortreal aa = 22, `endif\n"
+     " longint aaa = 222);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    int       a   = 2,\n"
+     "`ifdef MACRO\n"
+     "    shortreal aa  = 22,\n"
+     "`endif\n"
+     "    longint   aaa = 222\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'data_type list_of_param_assignments' and
+     // packed dimensions
+     "interface foo #(bit [1:0] a = 2,  reg [12:0] aa = 22, logic [123:0] aaa "
+     "= 222);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    bit   [  1:0] a   = 2,\n"
+     "    reg   [ 12:0] aa  = 22,\n"
+     "    logic [123:0] aaa = 222\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'data_type list_of_param_assignments' and
+     // unpacked dimensions
+     "interface foo #(bit  a[1:0] = 2,  reg  aa[12:0] = 22, logic aaa [123:0]  "
+     "= 222);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    bit   a  [  1:0] = 2,\n"
+     "    reg   aa [ 12:0] = 22,\n"
+     "    logic aaa[123:0] = 222\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'type list_of_type_assignments'
+     "interface foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    type T   = int,\n"
+     "    type TT  = bit,\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'type list_of_type_assignments' and
+     // comments
+     "interface foo #(//comment\ntype T = int, type TT = bit, type TTT= "
+     "C#(logic) );\n"
+     "endinterface\n",
+     "interface foo #(  //comment\n"
+     "    type T   = int,\n"
+     "    type TT  = bit,\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'data_type list_of_param_assignments' and
+     // trailing comments
+     "interface foo #(type T = int, type TT = bit, //comment\n type TTT= "
+     "C#(logic) );\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    type T   = int,\n"
+     "    type TT  = bit,       //comment\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'data_type list_of_param_assignments' and
+     // pre-proc
+     "interface foo #(type T = int,\n"
+     "`ifdef MACRO type TT = bit, `endif\n"
+     " type TTT= C#(logic));\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    type T   = int,\n"
+     "`ifdef MACRO\n"
+     "    type TT  = bit,\n"
+     "`endif\n"
+     "    type TTT = C#(logic)\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'data_type list_of_param_assignments' and
+     // packed dimensions
+     "interface foo #(type T = int [3:0], type TT = bit [250:0]);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    type T  = int [  3:0],\n"
+     "    type TT = bit [250:0]\n"
+     ");\n"
+     "endinterface\n"},
+    {"interface foo #(type T = int, "
+     "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, "
+     "localparam AAAAA = 22222, localparam real AAAAAA = 222222"
+     ");\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "               type    T      = int,\n"
+     "                       A      = 2,\n"
+     "               int     AA     = 22,\n"
+     "    parameter          AAA    = 222,\n"
+     "    parameter  longint AAAA   = 2222,\n"
+     "    localparam         AAAAA  = 22222,\n"
+     "    localparam real    AAAAAA = 222222\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with built-in data type
+     "interface foo #(int a = 2, real abc = 2234);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    int  a   = 2,\n"
+     "    real abc = 2234\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with type
+     "interface foo #(type TYPE1 = int, type TYPE2 = boo);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    type TYPE1 = int,\n"
+     "    type TYPE2 = boo\n"
+     ");\n"
+     "endinterface\n"},
+    {"interface foo#(localparam type TYPE1 = int, type TYPE22 = bool, "
+     "parameter    type TYPE333 = real);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    localparam type TYPE1   = int,\n"
+     "               type TYPE22  = bool,\n"
+     "    parameter  type TYPE333 = real\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'data_type list_of_param_assignments' and
+     // 1D packed dimensions
+     "interface foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    parameter type T  = int [  3:0],\n"
+     "              type TT = bit [123:0]\n"
+     ");\n"
+     "endinterface\n"},
+    {// parameterized interface with 'data_type list_of_param_assignments' and
+     // 2D packed dimensions
+     "interface foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    type T  = int [  3:0][123:0],\n"
+     "    type TT = bit [123:0][  1:0]\n"
+     ");\n"
+     "endinterface\n"},
+    {// parametrized interface with user defined data types
+     "interface foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n"
+     "endinterface\n",
+     "interface foo #(\n"
+     "    type T  = my_type1_t,\n"
+     "    type TT = my_pkg::my_type2_t\n"
+     ");\n"
+     "endinterface\n"},
+    {// wildcard import package at module header
+     "module foo import bar::*; (baz); endmodule\n",
+     "module foo\n"
+     "  import bar::*;\n"
+     "(\n"
+     "    baz\n"
+     ");\n"
+     "endmodule\n"},
+    {// import package at module header
+     "module foo import bar::baz; (qux); endmodule\n",
+     "module foo\n"
+     "  import bar::baz;\n"
+     "(\n"
+     "    qux\n"
+     ");\n"
+     "endmodule\n"},
+    {// wildcard import multiple packages at module header
+     "module foo import bar::*,baz::*; (qux); endmodule\n",
+     "module foo\n"
+     "  import bar::*, baz::*;\n"
+     "(\n"
+     "    qux\n"
+     ");\n"
+     "endmodule\n"},
+    {// separate package import declarations in module header
+     "module foo import bar::*,baz::*; import q_pkg::qux; (qux); endmodule\n",
+     "module foo\n"
+     "  import bar::*, baz::*;\n"
+     "  import q_pkg::qux;\n"
+     "(\n"
+     "    qux\n"
+     ");\n"
+     "endmodule\n"},
+    {// import package at module header
+     "module foo import bar::baz; #(int p = 3)(qux); endmodule\n",
+     "module foo\n"
+     "  import bar::baz;\n"
+     "#(\n"
+     "    int p = 3\n"
+     ") (\n"
+     "    qux\n"
+     ");\n"
+     "endmodule\n"},
+    // Space between return keyword and return value
+    {"function int foo(logic [31:0] data); return{<<8{data}}; endfunction",
+     "function int foo(logic [31:0] data);\n"
+     "  return {<<8{data}};\n"
+     "endfunction\n"},
+    {"function int f;return(1);endfunction",
+     "function int f;\n"
+     "  return (1);\n"
+     "endfunction\n"},
+    {"function int f;return-1;endfunction",
+     "function int f;\n"
+     "  return -1;\n"
+     "endfunction\n"},
+    {"function int f ;return    ! x\n;endfunction",
+     "function int f;\n"
+     "  return !x;\n"
+     "endfunction\n"},
+    {"function int f ;return    ~ x\n;endfunction",
+     "function int f;\n"
+     "  return ~x;\n"
+     "endfunction\n"},
+    {"function int f ;return    $x\n;endfunction",
+     "function int f;\n"
+     "  return $x;\n"
+     "endfunction\n"},
+    // String initializers
+    {"string a[] = {\n\"a\"\n};\n", "string a[] = {\"a\"};\n"},
+    {"string abc[] = {\n\"a\",\n\"b\",\n\"c\"\n};\n",
+     "string abc[] = {\"a\", \"b\", \"c\"};\n"},
+    {"string abc[] = {\n"
+     "\"a\",//\n"
+     "\"b\", \"c\"\n"
+     "};\n",
+     "string abc[] = {\"a\",  //\n"
+     "                \"b\",\n"
+     "                \"c\"};\n"},
+    {"string abc[] = {//\n"
+     "\"a\", \"b\", \"c\""
+     "};\n",
+     "string abc[] = {  //\n"
+     "  \"a\",\n"
+     "  \"b\",\n"
+     "  \"c\"\n"
+     "};\n"},
+    {"string abc[] = {\n"
+     "\"a\", \"b\", \"c\"//\n"
+     "};\n",
+     "string abc[] = {\"a\",\n"
+     "                \"b\",\n"
+     "                \"c\"  //\n"
+     "                };\n"},
+    {"string abc[] = {//\n"
+     "\"a\",//\n"
+     "\"b\", \"c\"//\n"
+     "};\n",
+     "string abc[] = {  //\n"
+     "  \"a\",  //\n"
+     "  \"b\",\n"
+     "  \"c\"  //\n"
+     "};\n"},
+    {"string abc[] = {\n"
+     "\"a\",\n"
+     "// comment\n"
+     "// comment\n"
+     "\"b\",\n"
+     "\"c\"\n"
+     "};\n",
+     "string abc[] = {\"a\",\n"
+     "                // comment\n"
+     "                // comment\n"
+     "                \"b\",\n"
+     "                \"c\"};\n"},
+    {"string numbers[] = {\"one\", \"two\", \"three\", \"four\"};\n",
+     "string numbers[] = {\"one\",\n"
+     "                    \"two\",\n"
+     "                    \"three\",\n"
+     "                    \"four\"};\n"},
+    {"string numbers[] = {\"one\", \"two\", THREE, \"four\"};\n",
+     "string numbers[] = {\n"
+     "  \"one\", \"two\", THREE, \"four\"\n"
+     "};\n"},
+    {"string numbers[] = {\"one\", {\"two\", \"three\"}, \"four\"};\n",
+     "string numbers[] = {\n"
+     "  \"one\", {\"two\", \"three\"}, \"four\"\n"
+     "};\n"},
+    {"string numbers[] = {\"one\", {\"two\", //\n"
+     "\"three\"}, \"four\"};\n",
+     "string numbers[] = {\n"
+     "  \"one\",\n"
+     "  {\n"
+     "    \"two\",  //\n"
+     "    \"three\"\n"
+     "  },\n"
+     "  \"four\"\n"
+     "};\n"},
+    {"string years[] = {\"two_thousand_nineteen\", \"two_thousand_twenty\",\n"
+     "\"two_thousand_twenty_one\"};\n",
+     // line with 3rd string would exceed column limit in unwrapped style
+     "string years[] = {\n"
+     "  \"two_thousand_nineteen\",\n"
+     "  \"two_thousand_twenty\",\n"
+     "  \"two_thousand_twenty_one\"\n"
+     "};\n"},
+    {"class class_name;\n"
+     "var_type var_name = new(\"the_string\");\n"
+     "endclass\n",
+     "class class_name;\n"
+     "  var_type var_name = new(\"the_string\");\n"
+     "endclass\n"},
+
+    //{   // parameterized class with 'parameter_declaration' and MACRO
+    //    "class foo #(parameter int a = 2,\n"
+    //    "parameter int aaa = `MACRO);\n"
+    //    "endclass\n",
+    //    "class foo #(\n"
+    //    "    parameter int a   = 2,\n"
+    //    "    parameter int aaa = `MACRO\n"
+    //    ");\n"
+    //    "endclass\n"
+    //},
+    // Struct/Union alignment
+    {"typedef struct {\n"
+     "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n"
+     "} type_t;",
+     "typedef struct {\n"
+     "  bit [3:0]           first;\n"
+     "  bit [31:0]          second;\n"
+     "  generic_type_name_t third;\n"
+     "} type_t;\n"},
+    {"typedef union soft packed {\n"
+     "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n"
+     "} type_t;",
+     "typedef union soft packed {\n"
+     "  bit [3:0]           first;\n"
+     "  bit [31:0]          second;\n"
+     "  generic_type_name_t third;\n"
+     "} type_t;\n"},
+    {"typedef union soft {\n"
+     "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n"
+     "} type_t;",
+     "typedef union soft {\n"
+     "  bit [3:0]           first;\n"
+     "  bit [31:0]          second;\n"
+     "  generic_type_name_t third;\n"
+     "} type_t;\n"},
+    {"typedef struct {\n"
+     "// comment\n"
+     "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n"
+     "} type_t;",
+     "typedef struct {\n"
+     "  // comment\n"
+     "  bit [3:0]           first;\n"
+     "  bit [31:0]          second;\n"
+     "  generic_type_name_t third;\n"
+     "} type_t;\n"},
+    {"typedef struct {\n"
+     "// comment 0\n"
+     "bit [31:0] first; // a\n"
+     "bit [31:0] second; // b\n"
+     "bit third; // c\n"
+     "uint fourth; // d\n"
+     "\n"
+     "// comment 1\n"
+     "int fifth;\n"
+     "// comment 2.1\n"
+     "// comment 2.2\n"
+     "uint sixth;\n"
+     "} timing_cfg_t;",
+     "typedef struct {\n"
+     "  // comment 0\n"
+     "  bit [31:0] first;   // a\n"
+     "  bit [31:0] second;  // b\n"
+     "  bit        third;   // c\n"
+     "  uint       fourth;  // d\n"
+     "\n"
+     "  // comment 1\n"
+     "  int  fifth;\n"
+     "  // comment 2.1\n"
+     "  // comment 2.2\n"
+     "  uint sixth;\n"
+     "} timing_cfg_t;\n"},
+    {"typedef struct {\n"
+     "// comment\n"
+     "rand int r;\n"
+     "int a;\n"
+     "int aa = 0;\n"
+     "int aaa = 1; // comment\n"
+     "foo#(bar) z;\n"
+     "int [x:y] zz; // comment\n"
+     "int zzz[a:b];\n"
+     "} type_t;",
+     "typedef struct {\n"
+     "  // comment\n"
+     "  rand int   r;\n"
+     "  int        a;\n"
+     "  int        aa        = 0;\n"
+     "  int        aaa       = 1;  // comment\n"
+     "  foo #(bar) z;\n"
+     "  int [x:y]  zz;             // comment\n"
+     "  int        zzz[a:b];\n"
+     "} type_t;\n"},
+    {"typedef struct packed {\n"
+     "struct packed { bit q; logic qq; logic qqq; } a_few_qs;\n"
+     "struct packed {\n"
+     "logic [1:0]  q;\n"
+     "} one_q;\n"
+     "int q;\n"
+     "uint qq;\n"
+     "} nested_qs_t;",
+     "typedef struct packed {\n"
+     "  struct packed {\n"
+     "    bit   q;\n"
+     "    logic qq;\n"
+     "    logic qqq;\n"
+     "  } a_few_qs;\n"
+     "  struct packed {logic [1:0] q;} one_q;\n"
+     "  int  q;\n"
+     "  uint qq;\n"
+     "} nested_qs_t;\n"},
+    {"typedef struct packed {\n"
+     "struct packed { bit q; logic qq; logic qqq; } a_few_qs;\n"
+     "struct packed {\n"
+     "// comment\n"
+     "logic [1:0]  q;\n"
+     "} one_q;\n"
+     "int q;\n"
+     "uint qq;\n"
+     "} nested_qs_t;",
+     "typedef struct packed {\n"
+     "  struct packed {\n"
+     "    bit   q;\n"
+     "    logic qq;\n"
+     "    logic qqq;\n"
+     "  } a_few_qs;\n"
+     "  struct packed {\n"
+     "    // comment\n"
+     "    logic [1:0] q;\n"
+     "  } one_q;\n"
+     "  int  q;\n"
+     "  uint qq;\n"
+     "} nested_qs_t;\n"},
+    {"typedef struct {bit [3:0] first;\n"
+     "`ifdef MACRO\n"
+     "bit [31:0] second; generic_type_name_t third;\n"
+     "`endif\n"
+     "} type_t;\n",
+     "typedef struct {\n"
+     "  bit [3:0]           first;\n"
+     "`ifdef MACRO\n"
+     "  bit [31:0]          second;\n"
+     "  generic_type_name_t third;\n"
+     "`endif\n"
+     "} type_t;\n"},
+    {"typedef struct {\n"
+     "bit [3:0] first // c\n"
+     "; bit [31:0] second"
+     "// c\n"
+     "; generic_type_name_t third // c\n"
+     ";} type_t;\n",
+     "typedef struct {\n"
+     "  bit [3:0]           first  // c\n"
+     ";\n"
+     "  bit [31:0]          second  // c\n"
+     ";\n"
+     "  generic_type_name_t third  // c\n"
+     ";\n"
+     "} type_t;\n"},
+    {"struct {logic test1; // c\n"
+     "logic test2;} test3;\n",
+     "struct {\n"
+     "  logic test1;  // c\n"
+     "  logic test2;\n"
+     "} test3;\n"},
+    {"struct {\n"
+     "  /* t */ logic test1; /* t */\n"
+     "/* t */ logic test2; }test3;\n",
+     "struct {\n"
+     "  /* t */ logic test1;  /* t */\n"
+     "  /* t */ logic test2;\n"
+     "} test3;\n"},
+    // Continuation comment alignment
+    {"`define BAR 1 // A\n"
+     "module foo(); // B\n"
+     "wire baz;     // C\n"
+     "endmodule:foo // D\n",
+     "`define BAR 1 // A\n"
+     "module foo ();  // B\n"
+     "  wire baz;  // C\n"
+     "endmodule : foo  // D\n"},
+    {"`define BAR 1 // A\n"
+     "module foo(); // B\n"
+     "              // B.1\n"
+     "              // B.2\n"
+     "wire baz;     // C\n"
+     "              // C.1\n"
+     "              // C.2\n"
+     "endmodule:foo // D\n"
+     "              // D.1\n"
+     "              // D.2\n",
+     "`define BAR 1 // A\n"
+     "module foo ();  // B\n"
+     "                // B.1\n"
+     "                // B.2\n"
+     "  wire baz;  // C\n"
+     "             // C.1\n"
+     "             // C.2\n"
+     "endmodule : foo  // D\n"
+     "                 // D.1\n"
+     "                 // D.2\n"},
+    {"// W\n"
+     "`define BAR 1 // A\n"
+     "   // X\n"
+     "module foo(); // B\n"
+     "              // B.1\n"
+     "              // B.2\n"
+     " // Y\n"
+     "wire baz;     // C\n"
+     "              // C.1\n"
+     "              // C.2\n"
+     "    // Z\n"
+     "endmodule:foo // D\n"
+     "              // D.1\n"
+     "              // D.2\n",
+     "// W\n"
+     "`define BAR 1 // A\n"
+     "// X\n"
+     "module foo ();  // B\n"
+     "                // B.1\n"
+     "                // B.2\n"
+     "  // Y\n"
+     "  wire baz;  // C\n"
+     "             // C.1\n"
+     "             // C.2\n"
+     "  // Z\n"
+     "endmodule : foo  // D\n"
+     "                 // D.1\n"
+     "                 // D.2\n"},
+    {"module foo( // A\n"
+     "            // A.1\n"
+     "// X\n"
+     "input wire i1 [a:b], // B\n"
+     "                     // B.1\n"
+     "input [c:d] i2, // C\n"
+     "                // C.1\n"
+     "\n"
+     "// Y\n"
+     "output reg o1 // D\n"
+     "              // D.1\n"
+     ");endmodule:foo\n",
+     "module foo (  // A\n"
+     "              // A.1\n"
+     "    // X\n"
+     "    input wire       i1[a:b],  // B\n"
+     "                               // B.1\n"
+     "    input      [c:d] i2,       // C\n"
+     "                               // C.1\n"
+     "\n"
+     "    // Y\n"
+     "    output reg o1  // D\n"
+     "                   // D.1\n"
+     ");\n"
+     "endmodule : foo\n"},
+    // user defined type alignment
+    {
+        "module foo();\n"
+        "  logic [5:0][5:0] net_c;\n"
+        " messy_type_name [1:0] net_e;\n"
+        "endmodule\n",
+        "module foo ();\n"
+        "  logic           [5:0][5:0] net_c;\n"
+        "  messy_type_name [1:0]      net_e;\n"
+        "endmodule\n",
+    },
+    // Continuation comment's original starting column is allowed to differ from
+    // starting comment's original starting column at most by 1.
+    // Starting column of comments B and C will change after formatting.
+    // TODO: refine the column alignment depending on current vs previous line.
+    // https://github.com/chipsalliance/verible/pull/858#discussion_r672844015
+    {"module foo ();  // A\n"     // Starting comment; already on correct column
+     "                 // A.1\n"  // A's column + 1
+     "               // A.2\n"    // A's column - 1
+     "wire baz;      // B\n"      // Starting comment; will be moved left
+     "              // B.1\n"     // B's column - 1
+     "                // B.2\n"   // B's column + 1
+     "               // B.3\n"    // B's column
+     "endmodule:foo // C\n"       // Starting comment; will be moved right
+     "               // C.1\n"    // C's column + 1
+     "             // C.2\n",     // C's column - 1
+     "module foo ();  // A\n"
+     "                // A.1\n"
+     "                // A.2\n"
+     "  wire baz;  // B\n"
+     "             // B.1\n"
+     "             // B.2\n"
+     "             // B.3\n"
+     "endmodule : foo  // C\n"
+     "                 // C.1\n"
+     "                 // C.2\n"},
+    {"module foo\n"
+     "#(\n"
+     "  parameter type baz_t = struct packed { `BAZ(); }\n"
+     ")\n"
+     "();\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    parameter type\n"
+     "        baz_t = struct packed {\n"
+     "      `BAZ();\n"
+     "    }\n"
+     ") ();\n"
+     "endmodule\n"},
+    // The same as the previous test case, but without a semicolon at the macro
+    // call
+    {"module foo\n"
+     "#(\n"
+     "  parameter type baz_t = struct packed { `BAZ() }\n"
+     ")\n"
+     "();\n"
+     "endmodule\n",
+     "module foo #(\n"
+     "    parameter type\n"
+     "        baz_t = struct packed {\n"
+     "      `BAZ()\n"
+     "    }\n"
+     ") ();\n"
+     "endmodule\n"},
+    // Check that comments with too large starting column difference are not
+    // aligned as continuation comments.
+    // Check that starting comments are not linked with a comment in
+    // comment-only line above them, even when the starting column is the same.
+    // All comments in this test case are aligned independently, i.e. none are
+    // "continuation comments".
+    {"                // comment1\n"  // A's column, but is above it
+     "module foo ();  // A\n"
+     "                  // comment2\n"  // A's column + 2
+     "              // comment3\n"      // A's column - 2
+     "wire baz;     // B\n"
+     "            // comment4\n"      // B's column - 2
+     "                // comment5\n"  // B's column + 2
+     "              // comment6\n"    // B's column, but not directly under B
+     "endmodule:foo // C\n"
+     "                // comment7\n"  // C's column + 2
+     "              // comment8\n",   // C's column, but not directly under B
+     "// comment1\n"
+     "module foo ();  // A\n"
+     "  // comment2\n"
+     "  // comment3\n"
+     "  wire baz;  // B\n"
+     "  // comment4\n"
+     "  // comment5\n"
+     "  // comment6\n"
+     "endmodule : foo  // C\n"
+     "// comment7\n"
+     "// comment8\n"},
+    // Continuation comment alignment when a line with the starting comment is
+    // wrapped.
+    {"module foo(output logic very_very_very_very_long_name // A\n"
+     "                                                      // A.1\n"
+     "); endmodule\n",
+     "module foo (\n"
+     "    output logic\n"
+     "        very_very_very_very_long_name  // A\n"
+     "                                       // A.1\n"
+     ");\n"
+     "endmodule\n"},
+
+    // Attachment of ',' to elements in enum list (with and without comments)
+    {"typedef enum {\n"
+     "  first , // c1\n"
+     "  second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  first,  // c1\n"
+     "  second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first ,\n"
+     "  // c1\n"
+     "  second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  first,\n"
+     "  // c1\n"
+     "  second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first // c1\n"
+     "  , second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "    first   // c1\n"
+     "  , second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first\n"
+     "  // c1\n"
+     "  , second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "    first\n"
+     "  // c1\n"
+     "  , second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first // c1\n"
+     "  , // c2\n"
+     "  second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  first   // c1\n"
+     "  ,  // c2\n"
+     "  second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first\n"
+     "  // c1\n"
+     "  ,\n"
+     "  // c2\n"
+     "  second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  first\n"
+     "  // c1\n"
+     "  ,  // c2\n"
+     "  second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first\n"
+     "  // c1\n"
+     "  , // c2\n"
+     "  // c3\n"
+     "  second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  first\n"
+     "  // c1\n"
+     "  ,  // c2\n"
+     "  // c3\n"
+     "  second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  // c1\n"
+     "  first\n"
+     "  // c2\n"
+     "  , // c3\n"
+     "  // c4\n"
+     "  second\n"
+     "  // c5\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  // c1\n"
+     "  first\n"
+     "  // c2\n"
+     "  ,  // c3\n"
+     "  // c4\n"
+     "  second\n"
+     "  // c5\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  // c1\n"
+     "  // c1+\n"
+     "  first // c2\n"
+     "        // c2+\n"
+     "  , // c3\n"
+     "    // c3+\n"
+     "  // c4\n"
+     "  // c4+\n"
+     "  second // c5\n"
+     "         // c5+\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  // c1\n"
+     "  // c1+\n"
+     "  first   // c2\n"
+     "          // c2+\n"
+     "  ,  // c3\n"
+     "     // c3+\n"
+     "  // c4\n"
+     "  // c4+\n"
+     "  second  // c5\n"
+     "          // c5+\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first , /* c1 */\n"
+     "  second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  first,  /* c1 */\n"
+     "  second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first ,\n"
+     "  /* c1 */\n"
+     "  second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  first,\n"
+     "  /* c1 */\n"
+     "  second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first /* c1 */\n"
+     "  , second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "    first   /* c1 */\n"
+     "  , second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first\n"
+     "  /* c1 */\n"
+     "  , second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "    first\n"
+     "  /* c1 */\n"
+     "  , second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first /* c1 */\n"
+     "  , /* c2 */\n"
+     "  second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  first   /* c1 */\n"
+     "  ,  /* c2 */\n"
+     "  second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  first\n"
+     "  /* c1 */\n"
+     "  ,\n"
+     "  /* c2 */\n"
+     "  second\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  first\n"
+     "  /* c1 */\n"
+     "  ,\n"
+     "  /* c2 */\n"
+     "  second\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  /* c1 */\n"
+     "  first\n"
+     "  /* c2 */\n"
+     "  , /* c3 */\n"
+     "  /* c4 */\n"
+     "  second\n"
+     "  /* c5 */\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  /* c1 */\n"
+     "  first\n"
+     "  /* c2 */\n"
+     "  ,  /* c3 */\n"
+     "  /* c4 */\n"
+     "  second\n"
+     "  /* c5 */\n"
+     "} e;\n"},
+    {"typedef enum {\n"
+     "  /* c1  */\n"
+     "  /* c1+ */\n"
+     "  first /* c2  */\n"
+     "        /* c2+ */\n"
+     "  , /* c3  */\n"
+     "    /* c3+ */\n"
+     "  /* c4  */\n"
+     "  /* c4+ */\n"
+     "  second /* c5  */\n"
+     "         /* c5+ */\n"
+     "} e;\n",
+     "typedef enum {\n"
+     "  /* c1  */\n"
+     "  /* c1+ */\n"
+     "  first   /* c2  */\n"
+     "  /* c2+ */\n"
+     "  ,  /* c3  */\n"
+     "  /* c3+ */\n"
+     "  /* c4  */\n"
+     "  /* c4+ */\n"
+     "  second  /* c5  */\n"
+     "  /* c5+ */\n"
+     "} e;\n"},
+    {"module m;\n"
+     "typedef enum {\n"
+     "  first,\n"
+     "  second\n"
+     "} // c\n"
+     "e;\n"
+     "endmodule\n",
+     "module m;\n"
+     "  typedef enum {\n"
+     "    first,\n"
+     "    second\n"
+     "  }  // c\n"
+     "  e;\n"
+     "endmodule\n"},
+    // Attachment of ';' preceded by EOL comment
+    {"module m;\n"
+     "typedef enum {\n"
+     "  first,\n"
+     "  second\n"
+     "} e // c\n"
+     ";\n"
+     "endmodule\n",
+     "module m;\n"
+     "  typedef enum {\n"
+     "    first,\n"
+     "    second\n"
+     "  } e  // c\n"
+     "  ;\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "typedef enum {\n"
+     "  first,\n"
+     "  second\n"
+     "} // c1\n"
+     "e // c2\n"
+     ";\n"
+     "endmodule\n",
+     "module m;\n"
+     "  typedef enum {\n"
+     "    first,\n"
+     "    second\n"
+     "  }  // c1\n"
+     "  e  // c2\n"
+     "  ;\n"
+     "endmodule\n"},
+    {"assign foo = bar\n"
+     "// comment\n"
+     ";\n",
+     "assign foo = bar\n"
+     "    // comment\n"
+     "    ;\n"},
+    {"assign foo = bar // comment\n"
+     ";\n",
+     "assign foo = bar  // comment\n"
+     ";\n"},
+
+    // Attachment of ',' to elements in PortActualList (with and without
+    // comments)
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    .first(1) // c1\n"
+     "    ,\n"
+     "    .second(2) // c2\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "        .first (1)  // c1\n"
+     "      , .second(2)  // c2\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    .first(1) // c1\n"
+     "    , .second(2) // c2\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "        .first (1)  // c1\n"
+     "      , .second(2)  // c2\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    .first(1)\n"
+     "    // c1\n"
+     "    ,\n"
+     "    .second(2)\n"
+     "    // c2\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "        .first (1)\n"
+     "      // c1\n"
+     "      , .second(2)\n"
+     "      // c2\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    .first(1)\n"
+     "    // c1\n"
+     "    , .second(2)\n"
+     "    // c2\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "        .first (1)\n"
+     "      // c1\n"
+     "      , .second(2)\n"
+     "      // c2\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    .first(1)\n"
+     "    // c1\n"
+     "    , // c2\n"
+     "    .second(2)\n"
+     "    // c3\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "      .first (1)\n"
+     "      // c1\n"
+     "      ,  // c2\n"
+     "      .second(2)\n"
+     "      // c3\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    // c1\n"
+     "    // c1+\n"
+     "    .first(1) // c2\n"
+     "              // c2+\n"
+     "    , // c3\n"
+     "      // c3+\n"
+     "    .second(2) // c4\n"
+     "               // c4+\n"
+     "    // c5\n"
+     "    // c5+\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "      // c1\n"
+     "      // c1+\n"
+     "      .first (1)  // c2\n"
+     "                  // c2+\n"
+     "      ,  // c3\n"
+     "         // c3+\n"
+     "      .second(2)  // c4\n"
+     "                  // c4+\n"
+     "      // c5\n"
+     "      // c5+\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    .first(1) /* c1 */\n"
+     "    ,\n"
+     "    .second(2) /* c2 */\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "        .first (1)  /* c1 */\n"
+     "      , .second(2)  /* c2 */\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    /* c1 */ .first(1),\n"
+     "    /* c2 */ .second(2)\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "      /* c1 */.first (1),\n"
+     "      /* c2 */.second(2)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    .first(1) /* c1 */\n"
+     "    , .second(2) /* c2 */\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "        .first (1)  /* c1 */\n"
+     "      , .second(2)  /* c2 */\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    /* c1 */.first(1)\n"
+     "    /* c2 */, .second(2)\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "      /* c1 */  .first (1)\n"
+     "      /* c2 */, .second(2)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    .first(1)\n"
+     "    /* c1 */\n"
+     "    ,\n"
+     "    .second(2)\n"
+     "    /* c2 */\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "        .first (1)\n"
+     "      /* c1 */\n"
+     "      , .second(2)\n"
+     "      /* c2 */\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    .first(1)\n"
+     "    /* c1 */\n"
+     "    , .second(2)\n"
+     "    /* c2 */\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "        .first (1)\n"
+     "      /* c1 */\n"
+     "      , .second(2)\n"
+     "      /* c2 */\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    .first(1)\n"
+     "    /* c1 */\n"
+     "    , /* c2 */\n"
+     "    .second(2)\n"
+     "    /* c3 */\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "      .first (1)\n"
+     "      /* c1 */\n"
+     "      ,  /* c2 */\n"
+     "      .second(2)\n"
+     "      /* c3 */\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    .first(1)\n"
+     "    /* c1 */\n"
+     "    , /* c2 */\n"
+     "    .second(2)\n"
+     "    /* c3 */\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "      .first (1)\n"
+     "      /* c1 */\n"
+     "      ,  /* c2 */\n"
+     "      .second(2)\n"
+     "      /* c3 */\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar foobar(\n"
+     "    /* c1  */\n"
+     "    /* c1+ */\n"
+     "    .first(1) /* c2  */\n"
+     "              /* c2+ */\n"
+     "    , /* c3  */\n"
+     "      /* c3+ */\n"
+     "    .second(2) /* c4  */\n"
+     "               /* c4+ */\n"
+     "    /* c5  */\n"
+     "    /* c5+ */\n"
+     "  );\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar foobar (\n"
+     "      /* c1  */\n"
+     "      /* c1+ */\n"
+     "      .first (1)  /* c2  */\n"
+     "      /* c2+ */\n"
+     "      ,  /* c3  */\n"
+     "      /* c3+ */\n"
+     "      .second(2)  /* c4  */\n"
+     "      /* c4+ */\n"
+     "      /* c5  */\n"
+     "      /* c5+ */\n"
+     "  );\n"
+     "endmodule\n"},
+
+    // Attachment of ',' to elements in ActualNamedParameterList (with and
+    // without comments)
+    {"module foo;\n"
+     "  bar#(\n"
+     "    .first(1) // c1\n"
+     "    ,\n"
+     "    .second(2) // c2\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "        .first (1)  // c1\n"
+     "      , .second(2)  // c2\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    .first(1) // c1\n"
+     "    , .second(2) // c2\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "        .first (1)  // c1\n"
+     "      , .second(2)  // c2\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    .first(1)\n"
+     "    // c1\n"
+     "    ,\n"
+     "    .second(2)\n"
+     "    // c2\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "        .first (1)\n"
+     "      // c1\n"
+     "      , .second(2)\n"
+     "      // c2\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    .first(1)\n"
+     "    // c1\n"
+     "    , .second(2)\n"
+     "    // c2\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "        .first (1)\n"
+     "      // c1\n"
+     "      , .second(2)\n"
+     "      // c2\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    .first(1)\n"
+     "    // c1\n"
+     "    , // c2\n"
+     "    .second(2)\n"
+     "    // c3\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "      .first (1)\n"
+     "      // c1\n"
+     "      ,  // c2\n"
+     "      .second(2)\n"
+     "      // c3\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    // c1\n"
+     "    // c1+\n"
+     "    .first(1) // c2\n"
+     "              // c2+\n"
+     "    , // c3\n"
+     "      // c3+\n"
+     "    .second(2) // c4\n"
+     "               // c4+\n"
+     "    // c5\n"
+     "    // c5+\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "      // c1\n"
+     "      // c1+\n"
+     "      .first (1)  // c2\n"
+     "                  // c2+\n"
+     "      ,  // c3\n"
+     "         // c3+\n"
+     "      .second(2)  // c4\n"
+     "                  // c4+\n"
+     "      // c5\n"
+     "      // c5+\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    .first(1) /* c1 */\n"
+     "    ,\n"
+     "    .second(2) /* c2 */\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "        .first (1)  /* c1 */\n"
+     "      , .second(2)  /* c2 */\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    /* c1 */ .first(1),\n"
+     "    /* c2 */ .second(2)\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "      /* c1 */.first (1),\n"
+     "      /* c2 */.second(2)\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    .first(1) /* c1 */\n"
+     "    , .second(2) /* c2 */\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "        .first (1)  /* c1 */\n"
+     "      , .second(2)  /* c2 */\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    /* c1 */.first(1)\n"
+     "    /* c2 */, .second(2)\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "      /* c1 */  .first (1)\n"
+     "      /* c2 */, .second(2)\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    .first(1)\n"
+     "    /* c1 */\n"
+     "    ,\n"
+     "    .second(2)\n"
+     "    /* c2 */\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "        .first (1)\n"
+     "      /* c1 */\n"
+     "      , .second(2)\n"
+     "      /* c2 */\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    .first(1)\n"
+     "    /* c1 */\n"
+     "    , .second(2)\n"
+     "    /* c2 */\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "        .first (1)\n"
+     "      /* c1 */\n"
+     "      , .second(2)\n"
+     "      /* c2 */\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    .first(1)\n"
+     "    /* c1 */\n"
+     "    , /* c2 */\n"
+     "    .second(2)\n"
+     "    /* c3 */\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "      .first (1)\n"
+     "      /* c1 */\n"
+     "      ,  /* c2 */\n"
+     "      .second(2)\n"
+     "      /* c3 */\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    .first(1)\n"
+     "    /* c1 */\n"
+     "    , /* c2 */\n"
+     "    .second(2)\n"
+     "    /* c3 */\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "      .first (1)\n"
+     "      /* c1 */\n"
+     "      ,  /* c2 */\n"
+     "      .second(2)\n"
+     "      /* c3 */\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+    {"module foo;\n"
+     "  bar#(\n"
+     "    /* c1  */\n"
+     "    /* c1+ */\n"
+     "    .first(1) /* c2  */\n"
+     "              /* c2+ */\n"
+     "    , /* c3  */\n"
+     "      /* c3+ */\n"
+     "    .second(2) /* c4  */\n"
+     "               /* c4+ */\n"
+     "    /* c5  */\n"
+     "    /* c5+ */\n"
+     "  ) baz ();\n"
+     "endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "      /* c1  */\n"
+     "      /* c1+ */\n"
+     "      .first (1)  /* c2  */\n"
+     "      /* c2+ */\n"
+     "      ,  /* c3  */\n"
+     "      /* c3+ */\n"
+     "      .second(2)  /* c4  */\n"
+     "      /* c4+ */\n"
+     "      /* c5  */\n"
+     "      /* c5+ */\n"
+     "  ) baz ();\n"
+     "endmodule\n"},
+
+    // ":" and "'{" in a single line
+    {"assign foo[2] =\n"
+     "'{\n"
+     "bar: 1'b1,  // c\n"
+     "baz: 1'b0,  // c\n"
+     "foobar: CONSTANT,\n"
+     "qux:\n"
+     "{\n"
+     "a,  // c\n"
+     "b\n"
+     "}\n"
+     "};\n",
+     "assign foo[2] = '{\n"
+     "        bar: 1'b1,  // c\n"
+     "        baz: 1'b0,  // c\n"
+     "        foobar: CONSTANT,\n"
+     "        qux: {\n"
+     "          a,  // c\n"
+     "          b\n"
+     "        }\n"
+     "    };\n"},
+    {"assign a = (b) ? '{c: d[e], f: '1} : g;\n",
+     "assign a = (b) ?\n"
+     "    '{c: d[e], f: '1}\n"
+     "    : g;\n"},
+
+    // -----------------------------------------------------------------
+    // Comments around `else`.
+    // Check whether `else` partition is found correctly and that actual code is
+    // not appended to EOL comments.
+
+    // generate if
+
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "else if (r) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  else if (r) assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "else if (r) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  // eol-c\n"
+     "  else if (r) assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "else // eol-c\n"
+     "if (r) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  else  // eol-c\n"
+     "  if (r) assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "else\n"
+     "// eol-c\n"
+     "if (r) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  else\n"
+     "  // eol-c\n"
+     "  if (r)\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "if (r) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  else  // eol-c\n"
+     "  if (r) assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if (r) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  else  // eol-c\n"
+     "  // eol-c\n"
+     "  if (r)\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if (r) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  else  // eol-c\n"
+     "  // eol-c\n"
+     "  if (r)\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if\n"
+     "// eol-c\n"
+     "(r) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  else  // eol-c\n"
+     "  // eol-c\n"
+     "  if\n"
+     "      // eol-c\n"
+     "      (r)\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "if\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "(r) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  // eol-c\n"
+     "  else  // eol-c\n"
+     "  // eol-c\n"
+     "  // eol-c\n"
+     "  if\n"
+     "      // eol-c\n"
+     "      // eol-c\n"
+     "      (r)\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+
+    // generate if with function call
+
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "else if (foo(x) == bar(1, 2)) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  else if (foo(x) == bar(1, 2))\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "else if (foo(x) == bar(1, 2)) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  // eol-c\n"
+     "  else if (foo(x) == bar(1, 2))\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "else // eol-c\n"
+     "if (foo(x) == bar(1, 2)) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  else  // eol-c\n"
+     "  if (foo(x) == bar(1, 2)) assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "else\n"
+     "// eol-c\n"
+     "if (foo(x) == bar(1, 2)) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  else\n"
+     "  // eol-c\n"
+     "  if (foo(\n"
+     "          x\n"
+     "      ) == bar(\n"
+     "          1, 2\n"
+     "      ))\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "if (foo(x) == bar(1, 2)) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  else  // eol-c\n"
+     "  if (foo(x) == bar(1, 2)) assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if (foo(x) == bar(1, 2)) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  else  // eol-c\n"
+     "  // eol-c\n"
+     "  if (foo(\n"
+     "          x\n"
+     "      ) == bar(\n"
+     "          1, 2\n"
+     "      ))\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if (foo(x) == bar(1, 2)) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  else  // eol-c\n"
+     "  // eol-c\n"
+     "  if (foo(\n"
+     "          x\n"
+     "      ) == bar(\n"
+     "          1, 2\n"
+     "      ))\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if\n"
+     "// eol-c\n"
+     "(foo(x) == bar(1, 2)) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  else  // eol-c\n"
+     "  // eol-c\n"
+     "  if\n"
+     "      // eol-c\n"
+     "      (foo(\n"
+     "          x\n"
+     "      ) == bar(\n"
+     "          1, 2\n"
+     "      ))\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "if (x) assign z=y;\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "if\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "(foo(x) == bar(1, 2)) assign z=w;\n"
+     "else assign x=y;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  if (x) assign z = y;\n"
+     "  // eol-c\n"
+     "  // eol-c\n"
+     "  else  // eol-c\n"
+     "  // eol-c\n"
+     "  // eol-c\n"
+     "  if\n"
+     "      // eol-c\n"
+     "      // eol-c\n"
+     "      (foo(\n"
+     "          x\n"
+     "      ) == bar(\n"
+     "          1, 2\n"
+     "      ))\n"
+     "    assign z = w;\n"
+     "  else assign x = y;\n"
+     "endmodule\n"},
+
+    // else begin
+
+    {"module zx;\n"
+     "always begin\n"
+     "if (a) b<=1;\n"
+     "// eol-c\n"
+     "else begin b<=2;\n"
+     "end\n"
+     "end\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always begin\n"
+     "    if (a) b <= 1;\n"
+     "    // eol-c\n"
+     "    else begin\n"
+     "      b <= 2;\n"
+     "    end\n"
+     "  end\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always begin\n"
+     "if (a) b<=1;\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "else begin b<=2;\n"
+     "end\n"
+     "end\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always begin\n"
+     "    if (a) b <= 1;\n"
+     "    // eol-c\n"
+     "    // eol-c\n"
+     "    else begin\n"
+     "      b <= 2;\n"
+     "    end\n"
+     "  end\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always begin\n"
+     "if (a) b<=1;\n"
+     "else // eol-c\n"
+     "begin b<=2;\n"
+     "end\n"
+     "end\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always begin\n"
+     "    if (a) b <= 1;\n"
+     "    else  // eol-c\n"
+     "    begin\n"
+     "      b <= 2;\n"
+     "    end\n"
+     "  end\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always begin\n"
+     "if (a) b<=1;\n"
+     "else\n"
+     "// eol-c\n"
+     "begin b<=2;\n"
+     "end\n"
+     "end\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always begin\n"
+     "    if (a) b <= 1;\n"
+     "    else\n"
+     "    // eol-c\n"
+     "    begin\n"
+     "      b <= 2;\n"
+     "    end\n"
+     "  end\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always begin\n"
+     "if (a) b<=1;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "begin b<=2;\n"
+     "end\n"
+     "end\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always begin\n"
+     "    if (a) b <= 1;\n"
+     "    // eol-c\n"
+     "    else  // eol-c\n"
+     "    begin\n"
+     "      b <= 2;\n"
+     "    end\n"
+     "  end\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always begin\n"
+     "if (a) b<=1;\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "begin b<=2;\n"
+     "end\n"
+     "end\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always begin\n"
+     "    if (a) b <= 1;\n"
+     "    else  // eol-c\n"
+     "    // eol-c\n"
+     "    begin\n"
+     "      b <= 2;\n"
+     "    end\n"
+     "  end\n"
+     "endmodule\n"},
+
+    // else if
+
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "else if (set) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    else if (set) assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "else if (set) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    // eol-c\n"
+     "    else if (set) assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "else // eol-c\n"
+     "if (set) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    else  // eol-c\n"
+     "    if (set) assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "else\n"
+     "// eol-c\n"
+     "if (set) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    else\n"
+     "    // eol-c\n"
+     "    if (set)\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "if (set) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    else  // eol-c\n"
+     "    if (set) assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if (set) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    else  // eol-c\n"
+     "    // eol-c\n"
+     "    if (set)\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if (set) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    else  // eol-c\n"
+     "    // eol-c\n"
+     "    if (set)\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if\n"
+     "// eol-c\n"
+     "(set) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    else  // eol-c\n"
+     "    // eol-c\n"
+     "    if\n"
+     "        // eol-c\n"
+     "        (set)\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "if\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "(set) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    // eol-c\n"
+     "    else  // eol-c\n"
+     "    // eol-c\n"
+     "    // eol-c\n"
+     "    if\n"
+     "        // eol-c\n"
+     "        // eol-c\n"
+     "        (set)\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+
+    // else if with function call
+
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "else if (foo(clr, set, 1)) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    else if (foo(clr, set, 1))\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "else if (foo(clr, set, 1)) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    // eol-c\n"
+     "    else if (foo(clr, set, 1))\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "else // eol-c\n"
+     "if (foo(clr, set, 1)) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    else  // eol-c\n"
+     "    if (foo(clr, set, 1)) assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "else\n"
+     "// eol-c\n"
+     "if (foo(clr, set, 1)) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    else\n"
+     "    // eol-c\n"
+     "    if (foo(\n"
+     "            clr, set, 1\n"
+     "        ))\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "if (foo(clr, set, 1)) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    else  // eol-c\n"
+     "    if (foo(clr, set, 1)) assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if (foo(clr, set, 1)) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    else  // eol-c\n"
+     "    // eol-c\n"
+     "    if (foo(\n"
+     "            clr, set, 1\n"
+     "        ))\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if (foo(clr, set, 1)) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    else  // eol-c\n"
+     "    // eol-c\n"
+     "    if (foo(\n"
+     "            clr, set, 1\n"
+     "        ))\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "if\n"
+     "// eol-c\n"
+     "(foo(clr, set, 1)) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    else  // eol-c\n"
+     "    // eol-c\n"
+     "    if\n"
+     "        // eol-c\n"
+     "        (foo(\n"
+     "            clr, set, 1\n"
+     "        ))\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+    {"module zx;\n"
+     "always @(clr or set)\n"
+     "if (clr) assign q=0;\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "else // eol-c\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "if\n"
+     "// eol-c\n"
+     "// eol-c\n"
+     "(foo(clr, set, 1)) assign q=1;\n"
+     "else deassign q;\n"
+     "endmodule\n",
+     "module zx;\n"
+     "  always @(clr or set)\n"
+     "    if (clr) assign q = 0;\n"
+     "    // eol-c\n"
+     "    // eol-c\n"
+     "    else  // eol-c\n"
+     "    // eol-c\n"
+     "    // eol-c\n"
+     "    if\n"
+     "        // eol-c\n"
+     "        // eol-c\n"
+     "        (foo(\n"
+     "            clr, set, 1\n"
+     "        ))\n"
+     "      assign q = 1;\n"
+     "    else deassign q;\n"
+     "endmodule\n"},
+
+    // -----------------------------------------------------------------
+    // Comments around and inside macro calls.
+
+};
+
+TEST(FormatterEndToEndTest, AlignFormatterTestCases) {
+  RunFormatterTestCases40(kAlignFormatterTestCases);
+}
+
+TEST(FormatterEndToEndTest, AlignmentGroupBoundaryNone) {
+  // Default behavior: separator comments and blank lines do NOT break groups.
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// Separator comment does not break alignment group
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "// ============\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo    = 1'b1;\n"
+       "  assign baar   = 1'b0;\n"
+       "  // ============\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.alignment_group_boundary = AlignmentGroupBoundary::kNone;
+  style.assignment_statement_alignment = AlignmentPolicy::kAlign;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, AlignmentGroupBoundarySeparatorComments) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// Separator comment breaks alignment group
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "// ============\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo  = 1'b1;\n"
+       "  assign baar = 1'b0;\n"
+       "  // ============\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// Dashes separator also breaks
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "// ------------\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo  = 1'b1;\n"
+       "  assign baar = 1'b0;\n"
+       "  // ------------\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// Captioned divider (text between separator runs) also breaks
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "// ------ section heading ------\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo  = 1'b1;\n"
+       "  assign baar = 1'b0;\n"
+       "  // ------ section heading ------\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// Leading-only divider run with trailing caption text
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "// ==== Registers\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo  = 1'b1;\n"
+       "  assign baar = 1'b0;\n"
+       "  // ==== Registers\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// No space after // also works
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "//============\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo  = 1'b1;\n"
+       "  assign baar = 1'b0;\n"
+       "  //============\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// Slash separator (/////) also works
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "//////////\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo  = 1'b1;\n"
+       "  assign baar = 1'b0;\n"
+       "  //////////\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// Regular comment does NOT break alignment
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "// Title text\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo    = 1'b1;\n"
+       "  assign baar   = 1'b0;\n"
+       "  // Title text\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// Multi-line comment block with separators
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "// ============\n"
+       "// Title\n"
+       "// ============\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo  = 1'b1;\n"
+       "  assign baar = 1'b0;\n"
+       "  // ============\n"
+       "  // Title\n"
+       "  // ============\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// Short repeated body (3 chars) does NOT break
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "// ---\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo    = 1'b1;\n"
+       "  assign baar   = 1'b0;\n"
+       "  // ---\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// Declarations also respect separator comments
+       "module m;\n"
+       "logic       a;\n"
+       "logic [7:0] b;\n"
+       "// ============\n"
+       "logic c_long_name;\n"
+       "logic d;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  logic       a;\n"
+       "  logic [7:0] b;\n"
+       "  // ============\n"
+       "  logic c_long_name;\n"
+       "  logic d;\n"
+       "endmodule\n"},
+      {// Statements in always blocks
+       "module m;\n"
+       "always_comb begin\n"
+       "aaaaa = b;\n"
+       "c     = 1'b0;\n"
+       "// ============\n"
+       "dd = eee;\n"
+       "ffffff = g;\n"
+       "end\n"
+       "endmodule\n",
+       "module m;\n"
+       "  always_comb begin\n"
+       "    aaaaa = b;\n"
+       "    c     = 1'b0;\n"
+       "    // ============\n"
+       "    dd     = eee;\n"
+       "    ffffff = g;\n"
+       "  end\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.alignment_group_boundary = AlignmentGroupBoundary::kSeparatorComments;
+  style.assignment_statement_alignment = AlignmentPolicy::kAlign;
+  style.module_net_variable_alignment = AlignmentPolicy::kAlign;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, AlignmentGroupBoundaryBlankLines) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// Blank line breaks alignment group
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo  = 1'b1;\n"
+       "  assign baar = 1'b0;\n"
+       "\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// No blank line: single alignment group
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo    = 1'b1;\n"
+       "  assign baar   = 1'b0;\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// Single item before blank line (not enough for alignment)
+       "module m;\n"
+       "assign foo = 1'b1;\n"
+       "\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo = 1'b1;\n"
+       "\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+      {// Separator comment does NOT break (only blank lines)
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "// ============\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo    = 1'b1;\n"
+       "  assign baar   = 1'b0;\n"
+       "  // ============\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.alignment_group_boundary = AlignmentGroupBoundary::kBlankLines;
+  style.assignment_statement_alignment = AlignmentPolicy::kAlign;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest,
+     AlignmentGroupBoundaryBlankLinesAndSeparatorComments) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// Both blank line and separator break groups
+       "module m;\n"
+       "assign foo  = 1'b1;\n"
+       "assign baar = 1'b0;\n"
+       "\n"
+       "assign baaaaz = 1'b1;\n"
+       "assign c      = 1'b0;\n"
+       "// ============\n"
+       "assign dd  = 1'b1;\n"
+       "assign eee = 1'b0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign foo  = 1'b1;\n"
+       "  assign baar = 1'b0;\n"
+       "\n"
+       "  assign baaaaz = 1'b1;\n"
+       "  assign c      = 1'b0;\n"
+       "  // ============\n"
+       "  assign dd  = 1'b1;\n"
+       "  assign eee = 1'b0;\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.alignment_group_boundary =
+      AlignmentGroupBoundary::kBlankLinesAndSeparatorComments;
+  style.assignment_statement_alignment = AlignmentPolicy::kAlign;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify kAlign behavior for body-level param/localparam declarations
+// in module and package bodies.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBasics) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// localparam alignment in module body
+       "module m;\n"
+       "localparam foo = 4'b0000;\n"
+       "localparam barr = 4'b0010;\n"
+       "localparam baaaaz = 4'b0111;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo    = 4'b0000;\n"
+       "  localparam barr   = 4'b0010;\n"
+       "  localparam baaaaz = 4'b0111;\n"
+       "endmodule\n"},
+      {// localparam alignment in package body
+       "package p;\n"
+       "localparam foo = 4'b0000;\n"
+       "localparam barr = 4'b0010;\n"
+       "localparam baaaaz = 4'b0111;\n"
+       "endpackage\n",
+       "package p;\n"
+       "  localparam foo    = 4'b0000;\n"
+       "  localparam barr   = 4'b0010;\n"
+       "  localparam baaaaz = 4'b0111;\n"
+       "endpackage\n"},
+      {// parameter alignment in module body
+       "module m;\n"
+       "parameter int foo = 1;\n"
+       "parameter int barr = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter int foo  = 1;\n"
+       "  parameter int barr = 2;\n"
+       "endmodule\n"},
+      {// parameter alignment in package body
+       "package p;\n"
+       "parameter int foo = 1;\n"
+       "parameter int barrrr = 2;\n"
+       "endpackage\n",
+       "package p;\n"
+       "  parameter int foo    = 1;\n"
+       "  parameter int barrrr = 2;\n"
+       "endpackage\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify kFlushLeft behavior: body-level param/localparam declarations
+// are not aligned.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentFlushLeft) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// module body: parameters are not aligned
+       "module m;\n"
+       "localparam foo = 4'b0000;\n"
+       "localparam barr = 4'b0010;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo = 4'b0000;\n"
+       "  localparam barr = 4'b0010;\n"
+       "endmodule\n"},
+      {// package context: flush-left
+       "package p;\n"
+       "localparam foo = 4'b0000;\n"
+       "localparam barr = 4'b0010;\n"
+       "endpackage\n",
+       "package p;\n"
+       "  localparam foo = 4'b0000;\n"
+       "  localparam barr = 4'b0010;\n"
+       "endpackage\n"},
+      {// generate context: flush-left
+       "module m;\n"
+       "generate\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "endgenerate\n"
+       "endmodule\n",
+       "module m;\n"
+       "  generate\n"
+       "    localparam foo = 1;\n"
+       "    localparam barr = 2;\n"
+       "  endgenerate\n"
+       "endmodule\n"},
+      {// parameter in module body: flush-left
+       "module m;\n"
+       "parameter int W = 8;\n"
+       "parameter int HHHH = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter int W = 8;\n"
+       "  parameter int HHHH = 2;\n"
+       "endmodule\n"},
+      {// mixed parameter and localparam: flush-left, no alignment
+       "module m;\n"
+       "parameter int W = 8;\n"
+       "localparam L = 4;\n"
+       "parameter int H = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter int W = 8;\n"
+       "  localparam L = 4;\n"
+       "  parameter int H = 2;\n"
+       "endmodule\n"},
+      {// interface context: flush-left
+       "interface my_if;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "endinterface\n",
+       "interface my_if;\n"
+       "  localparam foo = 1;\n"
+       "  localparam barr = 2;\n"
+       "endinterface\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify kPreserve behavior: body-level param/localparam declarations
+// maintain their existing spacing.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPreserve) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// module body: existing spacing is kept
+       "module m;\n"
+       "localparam foo = 4'b0000;\n"
+       "localparam barr  = 4'b0010;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo = 4'b0000;\n"
+       "  localparam barr  = 4'b0010;\n"
+       "endmodule\n"},
+      {// package: existing flush-left spacing preserved
+       "package p;\n"
+       "localparam foo = 4'b0000;\n"
+       "localparam barr = 4'b0010;\n"
+       "endpackage\n",
+       "package p;\n"
+       "  localparam foo = 4'b0000;\n"
+       "  localparam barr = 4'b0010;\n"
+       "endpackage\n"},
+      {// generate: existing aligned spacing preserved
+       "module m;\n"
+       "generate\n"
+       "localparam foo  = 1;\n"
+       "localparam barr = 2;\n"
+       "endgenerate\n"
+       "endmodule\n",
+       "module m;\n"
+       "  generate\n"
+       "    localparam foo  = 1;\n"
+       "    localparam barr = 2;\n"
+       "  endgenerate\n"
+       "endmodule\n"},
+      {// parameter flush-left preserved
+       "module m;\n"
+       "parameter int W = 8;\n"
+       "parameter int HHHH = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter int W = 8;\n"
+       "  parameter int HHHH = 2;\n"
+       "endmodule\n"},
+      {// parameter pre-aligned preserved
+       "module m;\n"
+       "parameter int W    = 8;\n"
+       "parameter int HHHH = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter int W    = 8;\n"
+       "  parameter int HHHH = 2;\n"
+       "endmodule\n"},
+      {// interface pre-aligned preserved
+       "interface my_if;\n"
+       "localparam foo  = 1;\n"
+       "localparam barr = 2;\n"
+       "endinterface\n",
+       "interface my_if;\n"
+       "  localparam foo  = 1;\n"
+       "  localparam barr = 2;\n"
+       "endinterface\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kPreserve;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify kAlign behavior for param/localparam declarations across
+// interface, generate, and module body contexts, including mixed
+// param/localparam and packed dimension alignment.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentContexts) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// interface body localparam alignment
+       "interface my_if;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "endinterface\n",
+       "interface my_if;\n"
+       "  localparam foo  = 1;\n"
+       "  localparam barr = 2;\n"
+       "endinterface\n"},
+      {// interface body parameter alignment
+       "interface my_if;\n"
+       "parameter int X = 1;\n"
+       "parameter int Y_LONG = 2;\n"
+       "endinterface\n",
+       "interface my_if;\n"
+       "  parameter int X      = 1;\n"
+       "  parameter int Y_LONG = 2;\n"
+       "endinterface\n"},
+      {// generate block localparam alignment
+       "module m;\n"
+       "generate\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "endgenerate\n"
+       "endmodule\n",
+       "module m;\n"
+       "  generate\n"
+       "    localparam foo  = 1;\n"
+       "    localparam barr = 2;\n"
+       "  endgenerate\n"
+       "endmodule\n"},
+      {// generate block parameter alignment
+       "module m;\n"
+       "generate\n"
+       "parameter int A = 1;\n"
+       "parameter int BB = 2;\n"
+       "endgenerate\n"
+       "endmodule\n",
+       "module m;\n"
+       "  generate\n"
+       "    parameter int A  = 1;\n"
+       "    parameter int BB = 2;\n"
+       "  endgenerate\n"
+       "endmodule\n"},
+      {// mixed param and net declarations form separate alignment groups
+       "module m;\n"
+       "localparam X = 1;\n"
+       "localparam YYY = 2;\n"
+       "logic clk;\n"
+       "logic rst_n;\n"
+       "localparam ZZ = 3;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam X   = 1;\n"
+       "  localparam YYY = 2;\n"
+       "  logic clk;\n"
+       "  logic rst_n;\n"
+       "  localparam ZZ = 3;\n"
+       "endmodule\n"},
+      {// mixed parameter and localparam in same block
+       "module m;\n"
+       "parameter int W = 8;\n"
+       "localparam L = 4;\n"
+       "parameter int H = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter  int W = 8;\n"
+       "  localparam     L = 4;\n"
+       "  parameter  int H = 2;\n"
+       "endmodule\n"},
+      {// packed dimensions are aligned
+       "module m;\n"
+       "parameter bit [7:0] X = 0;\n"
+       "parameter bit [31:0] YYYY = 1;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter bit [ 7:0] X    = 0;\n"
+       "  parameter bit [31:0] YYYY = 1;\n"
+       "endmodule\n"},
+      {// multi-identifier comma-separated params are not split (no-crash)
+       "module m;\n"
+       "parameter int a=1, b=2, ccc=3;\n"
+       "localparam d=4, e=5;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter  int a = 1, b = 2, ccc = 3;\n"
+       "  localparam     d = 4, e = 5;\n"
+       "endmodule\n"},
+      {// parameter type declarations do not crash
+       "module m;\n"
+       "parameter type T = int;\n"
+       "parameter type TT_LONG = bit;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter type T = int;\n"
+       "  parameter type TT_LONG = bit;\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify kInferUserIntent behavior: body-level param/localparam
+// declarations infer alignment intent from existing spacing.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentInferUserIntent) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// flush-left localparams with small spacing diff: infer aligns
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo  = 1;\n"
+       "  localparam barr = 2;\n"
+       "endmodule\n"},
+      {// pre-aligned localparams: infer preserves alignment
+       "module m;\n"
+       "localparam foo    = 1;\n"
+       "localparam barr   = 2;\n"
+       "localparam baaaaz = 3;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo    = 1;\n"
+       "  localparam barr   = 2;\n"
+       "  localparam baaaaz = 3;\n"
+       "endmodule\n"},
+      {// flush-left params in package with small spacing diff: infer aligns
+       "package p;\n"
+       "localparam X = 1;\n"
+       "localparam YY = 2;\n"
+       "endpackage\n",
+       "package p;\n"
+       "  localparam X  = 1;\n"
+       "  localparam YY = 2;\n"
+       "endpackage\n"},
+      {// mixed param/localparam flush-left: infer keeps flush-left
+       "module m;\n"
+       "parameter int W = 8;\n"
+       "localparam L = 4;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter int W = 8;\n"
+       "  localparam L = 4;\n"
+       "endmodule\n"},
+      {// interface flush-left with small diff: infer aligns
+       "interface my_if;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "endinterface\n",
+       "interface my_if;\n"
+       "  localparam foo  = 1;\n"
+       "  localparam barr = 2;\n"
+       "endinterface\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify boundary behavior for param declarations with
+// kBlankLinesAndSeparatorComments: both blank lines and separator comments
+// break alignment groups.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundary) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// separator comment breaks param alignment group
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "// ============\n"
+       "localparam baaaaz = 1;\n"
+       "localparam c = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo  = 1;\n"
+       "  localparam barr = 2;\n"
+       "  // ============\n"
+       "  localparam baaaaz = 1;\n"
+       "  localparam c      = 2;\n"
+       "endmodule\n"},
+      {// blank line breaks param alignment group
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "\n"
+       "localparam baaaaz = 1;\n"
+       "localparam c = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo  = 1;\n"
+       "  localparam barr = 2;\n"
+       "\n"
+       "  localparam baaaaz = 1;\n"
+       "  localparam c      = 2;\n"
+       "endmodule\n"},
+      {// no separator: single alignment group (all aligned together)
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "localparam baaaaz = 1;\n"
+       "localparam c = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo    = 1;\n"
+       "  localparam barr   = 2;\n"
+       "  localparam baaaaz = 1;\n"
+       "  localparam c      = 2;\n"
+       "endmodule\n"},
+      {// regular comment does NOT break alignment group
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "// regular comment\n"
+       "localparam barr = 2;\n"
+       "localparam baaaaz = 1;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo    = 1;\n"
+       "  // regular comment\n"
+       "  localparam barr   = 2;\n"
+       "  localparam baaaaz = 1;\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  style.alignment_group_boundary =
+      AlignmentGroupBoundary::kBlankLinesAndSeparatorComments;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify edge cases: unpacked dimensions, signed/unsigned, implicit types,
+// complex types, single declarations, deeply nested generate blocks.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentEdgeCases) {
+  // Use column_limit = 80 to avoid unintended line wrapping inside
+  // deeply nested generate blocks (generate-if, generate-for), which
+  // would interfere with verifying alignment behavior.
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// unpacked dimension alignment
+       "module m;\n"
+       "parameter bit X [7:0] = 0;\n"
+       "parameter bit YYYY [15:0] = 1;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter bit X   [ 7:0] = 0;\n"
+       "  parameter bit YYYY[15:0] = 1;\n"
+       "endmodule\n"},
+      {// param declarations with only type and default value (no idim)
+       "module m;\n"
+       "parameter int X = 0;\n"
+       "parameter int YYYY = 0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter int X    = 0;\n"
+       "  parameter int YYYY = 0;\n"
+       "endmodule\n"},
+      {// signed modifier with packed dimensions
+       "module m;\n"
+       "parameter bit signed [7:0] X = 0;\n"
+       "parameter bit signed [31:0] YYYY = 1;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter bit signed [ 7:0] X    = 0;\n"
+       "  parameter bit signed [31:0] YYYY = 1;\n"
+       "endmodule\n"},
+      {// param with complex type (struct/typedef) — does not crash
+       "module m;\n"
+       "parameter foo_t X = foo_t'(0);\n"
+       "parameter foo_t Y_LONG = foo_t'(0);\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter foo_t X      = foo_t'(0);\n"
+       "  parameter foo_t Y_LONG = foo_t'(0);\n"
+       "endmodule\n"},
+      {// single param declaration (not enough for alignment group)
+       "module m;\n"
+       "localparam X = 1;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam X = 1;\n"
+       "endmodule\n"},
+      {// params inside generate-if block
+       "module m;\n"
+       "generate\n"
+       "if (1) begin : blk\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "end\n"
+       "endgenerate\n"
+       "endmodule\n",
+       "module m;\n"
+       "  generate\n"
+       "    if (1) begin : blk\n"
+       "      localparam foo  = 1;\n"
+       "      localparam barr = 2;\n"
+       "    end\n"
+       "  endgenerate\n"
+       "endmodule\n"},
+      {// unsigned keyword with packed dimensions (complement to signed)
+       "module m;\n"
+       "parameter bit unsigned [7:0] X = 0;\n"
+       "parameter bit unsigned [31:0] YYYY = 1;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter bit unsigned [ 7:0] X    = 0;\n"
+       "  parameter bit unsigned [31:0] YYYY = 1;\n"
+       "endmodule\n"},
+      {// parameter with implicit type (no explicit type keyword)
+       "module m;\n"
+       "parameter X = 32;\n"
+       "parameter Y_LONG = 64;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter X      = 32;\n"
+       "  parameter Y_LONG = 64;\n"
+       "endmodule\n"},
+      {// params inside generate-for block
+       "module m;\n"
+       "generate\n"
+       "for (i = 0; i < 2; i++) begin : blk\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "end\n"
+       "endgenerate\n"
+       "endmodule\n",
+       "module m;\n"
+       "  generate\n"
+       "    for (i = 0; i < 2; i++) begin : blk\n"
+       "      localparam foo  = 1;\n"
+       "      localparam barr = 2;\n"
+       "    end\n"
+       "  endgenerate\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 80;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify parameter declarations inside generate-case blocks are aligned.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentGenerateCase) {
+  // Params inside generate-case need wider column limit to avoid wrapping the
+  // case label / begin block line.
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// params inside generate-case block
+       "module m #(P = 0);\n"
+       "generate\n"
+       "case (P)\n"
+       "0: begin : blk\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "end\n"
+       "endcase\n"
+       "endgenerate\n"
+       "endmodule\n",
+       "module m #(\n"
+       "    P = 0\n"
+       ");\n"
+       "  generate\n"
+       "    case (P)\n"
+       "      0: begin : blk\n"
+       "        localparam foo  = 1;\n"
+       "        localparam barr = 2;\n"
+       "      end\n"
+       "    endcase\n"
+       "  endgenerate\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 80;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, FormalAndBodyParamAlignmentIndependence) {
+  // Verify that --formal_parameters_alignment and
+  // --parameter_declaration_alignment act independently: setting formal params
+  // to kFlushLeft should not affect body-level param alignment, and vice versa.
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// formal flush-left + body align: only body params align
+       "module m #(\n"
+       "int W = 2,\n"
+       "int LLLL = 4\n"
+       ");\n"
+       "localparam foo = 0;\n"
+       "localparam barrrr = 0;\n"
+       "endmodule\n",
+       "module m #(\n"
+       "    int W = 2,\n"
+       "    int LLLL = 4\n"
+       ");\n"
+       "  localparam foo    = 0;\n"
+       "  localparam barrrr = 0;\n"
+       "endmodule\n"},
+      {// formal align + body flush-left: only formal params align
+       "module m #(\n"
+       "int W = 2,\n"
+       "int LLLL = 4\n"
+       ");\n"
+       "localparam foo = 0;\n"
+       "localparam barrrr = 0;\n"
+       "endmodule\n",
+       "module m #(\n"
+       "    int W    = 2,\n"
+       "    int LLLL = 4\n"
+       ");\n"
+       "  localparam foo = 0;\n"
+       "  localparam barrrr = 0;\n"
+       "endmodule\n"},
+      {// both flush-left: no alignment anywhere
+       "module m #(\n"
+       "int W = 2,\n"
+       "int LLLL = 4\n"
+       ");\n"
+       "localparam foo = 0;\n"
+       "localparam barrrr = 0;\n"
+       "endmodule\n",
+       "module m #(\n"
+       "    int W = 2,\n"
+       "    int LLLL = 4\n"
+       ");\n"
+       "  localparam foo = 0;\n"
+       "  localparam barrrr = 0;\n"
+       "endmodule\n"},
+      {// both align: both formal and body params aligned
+       "module m #(\n"
+       "int W = 2,\n"
+       "int LLLL = 4\n"
+       ");\n"
+       "localparam foo = 0;\n"
+       "localparam barrrr = 0;\n"
+       "endmodule\n",
+       "module m #(\n"
+       "    int W    = 2,\n"
+       "    int LLLL = 4\n"
+       ");\n"
+       "  localparam foo    = 0;\n"
+       "  localparam barrrr = 0;\n"
+       "endmodule\n"},
+  };
+  // First case: formal kFlushLeft, body kAlign
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+    style.formal_parameters_alignment = AlignmentPolicy::kFlushLeft;
+    const auto &tc = kTestCases[0];
+    VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+  // Second case: formal kAlign, body kFlushLeft
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft;
+    style.formal_parameters_alignment = AlignmentPolicy::kAlign;
+    const auto &tc = kTestCases[1];
+    VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+  // Third case: both kFlushLeft
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft;
+    style.formal_parameters_alignment = AlignmentPolicy::kFlushLeft;
+    const auto &tc = kTestCases[2];
+    VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+  // Fourth case: both kAlign
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+    style.formal_parameters_alignment = AlignmentPolicy::kAlign;
+    const auto &tc = kTestCases[3];
+    VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, ClassBodyParamNotAffected) {
+  // Verify that class body parameter/localparam declarations are NOT affected
+  // by --parameter_declaration_alignment, which targets only module/generate/
+  // package/interface body-level params.
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// class body params are not affected
+       "class c;\n"
+       "parameter int X = 1;\n"
+       "parameter int YYYY = 2;\n"
+       "localparam foo = 3;\n"
+       "localparam barrrr = 4;\n"
+       "endclass\n",
+       "class c;\n"
+       "  parameter int X = 1;\n"
+       "  parameter int YYYY = 2;\n"
+       "  localparam foo = 3;\n"
+       "  localparam barrrr = 4;\n"
+       "endclass\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, PackageBodyVariableAlignment) {
+  // Verify that moving kPackageItemList to kTabularAlignment in tree-unwrapper
+  // enables net/variable declaration alignment in package bodies via
+  // module_net_variable_alignment.
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// net/variable declaration alignment in package body
+       "package p;\n"
+       "logic [7:0] a;\n"
+       "logic [31:0] bb;\n"
+       "endpackage\n",
+       "package p;\n"
+       "  logic [ 7:0] a;\n"
+       "  logic [31:0] bb;\n"
+       "endpackage\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.module_net_variable_alignment = AlignmentPolicy::kAlign;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentApplyToAll) {
+  // Verify that ApplyToAllAlignmentPolicies affects
+  // parameter_declaration_alignment for all four alignment policies.
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// kAlign aligns identifiers and = signs across declarations
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barrrr = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo    = 1;\n"
+       "  localparam barrrr = 2;\n"
+       "endmodule\n"},
+      {// kFlushLeft: declarations remain flush-left
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barrrr = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo = 1;\n"
+       "  localparam barrrr = 2;\n"
+       "endmodule\n"},
+      {// kPreserve: existing spacing is kept
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barrrr  = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo = 1;\n"
+       "  localparam barrrr  = 2;\n"
+       "endmodule\n"},
+      {// kInferUserIntent: large identifier width difference (3 cols)
+       // suggests flush-left intent, no alignment.
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barrrr = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo = 1;\n"
+       "  localparam barrrr = 2;\n"
+       "endmodule\n"},
+  };
+  // kAlign
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kAlign);
+    const auto &tc = kTestCases[0];
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+  // kFlushLeft
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kFlushLeft);
+    const auto &tc = kTestCases[1];
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+  // kPreserve
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kPreserve);
+    const auto &tc = kTestCases[2];
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+  // kInferUserIntent
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kInferUserIntent);
+    const auto &tc = kTestCases[3];
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+}
+
+// Verify that alignment_group_boundary=kBlankLines treats only blank lines
+// (not separator comments) as boundary breaks for param declarations.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundaryBlankLines) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// Only blank line breaks group; separator comment does not
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "\n"
+       "localparam baaaaz = 1;\n"
+       "localparam c = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo  = 1;\n"
+       "  localparam barr = 2;\n"
+       "\n"
+       "  localparam baaaaz = 1;\n"
+       "  localparam c      = 2;\n"
+       "endmodule\n"},
+      {// Separator comment does NOT break group with kBlankLines
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "// ============\n"
+       "localparam baaaaz = 1;\n"
+       "localparam c = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo    = 1;\n"
+       "  localparam barr   = 2;\n"
+       "  // ============\n"
+       "  localparam baaaaz = 1;\n"
+       "  localparam c      = 2;\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  style.alignment_group_boundary = AlignmentGroupBoundary::kBlankLines;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify that alignment_group_boundary=kNone keeps all param declarations
+// in a single alignment group regardless of blank lines or comments.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundaryNone) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// Blank line does NOT break group with kNone
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "\n"
+       "localparam baaaaz = 1;\n"
+       "localparam c = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo    = 1;\n"
+       "  localparam barr   = 2;\n"
+       "\n"
+       "  localparam baaaaz = 1;\n"
+       "  localparam c      = 2;\n"
+       "endmodule\n"},
+      {// Separator comment does NOT break group with kNone
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "// ============\n"
+       "localparam baaaaz = 1;\n"
+       "localparam c = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo    = 1;\n"
+       "  localparam barr   = 2;\n"
+       "  // ============\n"
+       "  localparam baaaaz = 1;\n"
+       "  localparam c      = 2;\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  style.alignment_group_boundary = AlignmentGroupBoundary::kNone;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify that alignment_group_boundary=kSeparatorComments treats only
+// separator comments (not blank lines) as boundary breaks for param
+// declarations.
+TEST(FormatterEndToEndTest,
+     ParamDeclarationAlignmentBoundarySeparatorComments) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// Separator comment breaks alignment group
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "// ============\n"
+       "localparam baaaaz = 1;\n"
+       "localparam c = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo  = 1;\n"
+       "  localparam barr = 2;\n"
+       "  // ============\n"
+       "  localparam baaaaz = 1;\n"
+       "  localparam c      = 2;\n"
+       "endmodule\n"},
+      {// Blank line does NOT break group with kSeparatorComments
+       "module m;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "\n"
+       "localparam baaaaz = 1;\n"
+       "localparam c = 2;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam foo    = 1;\n"
+       "  localparam barr   = 2;\n"
+       "\n"
+       "  localparam baaaaz = 1;\n"
+       "  localparam c      = 2;\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  style.alignment_group_boundary = AlignmentGroupBoundary::kSeparatorComments;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify that class body parameter/localparam declarations are NOT affected
+// by --parameter_declaration_alignment for the kFlushLeft, kPreserve,
+// and kInferUserIntent policies (kAlign is covered in
+// ClassBodyParamNotAffected).
+TEST(FormatterEndToEndTest, ClassBodyParamNotAffectedOtherPolicies) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// kFlushLeft: class body params remain flush-left
+       "class c;\n"
+       "parameter int X = 1;\n"
+       "parameter int YYYY = 2;\n"
+       "localparam foo = 3;\n"
+       "localparam barrrr = 4;\n"
+       "endclass\n",
+       "class c;\n"
+       "  parameter int X = 1;\n"
+       "  parameter int YYYY = 2;\n"
+       "  localparam foo = 3;\n"
+       "  localparam barrrr = 4;\n"
+       "endclass\n"},
+      {// kPreserve: parameter_declaration_alignment does not apply to class
+       // bodies; whitespace is normalized by default formatting.
+       "class c;\n"
+       "parameter int X     = 1;\n"
+       "parameter int YYYY  = 2;\n"
+       "endclass\n",
+       "class c;\n"
+       "  parameter int X = 1;\n"
+       "  parameter int YYYY = 2;\n"
+       "endclass\n"},
+      {// kInferUserIntent: class body params infer flush-left
+       "class c;\n"
+       "parameter int X = 1;\n"
+       "parameter int YYYY = 2;\n"
+       "endclass\n",
+       "class c;\n"
+       "  parameter int X = 1;\n"
+       "  parameter int YYYY = 2;\n"
+       "endclass\n"},
+  };
+  // kFlushLeft
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft;
+    const auto &tc = kTestCases[0];
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+  // kPreserve
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.parameter_declaration_alignment = AlignmentPolicy::kPreserve;
+    const auto &tc = kTestCases[1];
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+  // kInferUserIntent
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent;
+    const auto &tc = kTestCases[2];
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+}
+
+// Verify formal_parameters_alignment and parameter_declaration_alignment
+// independence for kPreserve and kInferUserIntent combinations.
+TEST(FormatterEndToEndTest,
+     FormalAndBodyParamAlignmentIndependenceOtherPolicies) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// formal kPreserve + body kAlign: only body params aligned
+       "module m #(\n"
+       "int W = 2,\n"
+       "int LLLL = 4\n"
+       ");\n"
+       "localparam foo = 0;\n"
+       "localparam barrrr = 0;\n"
+       "endmodule\n",
+       "module m #(\n"
+       "    int W = 2,\n"
+       "    int LLLL = 4\n"
+       ");\n"
+       "  localparam foo    = 0;\n"
+       "  localparam barrrr = 0;\n"
+       "endmodule\n"},
+      {// formal kAlign + body kPreserve: only formal params aligned
+       "module m #(\n"
+       "int W = 2,\n"
+       "int LLLL = 4\n"
+       ");\n"
+       "localparam foo   = 0;\n"
+       "localparam barrrr = 0;\n"
+       "endmodule\n",
+       "module m #(\n"
+       "    int W    = 2,\n"
+       "    int LLLL = 4\n"
+       ");\n"
+       "  localparam foo   = 0;\n"
+       "  localparam barrrr = 0;\n"
+       "endmodule\n"},
+      {// formal kInferUserIntent + body kAlign: only body params aligned
+       "module m #(\n"
+       "int W = 2,\n"
+       "int LLLL = 4\n"
+       ");\n"
+       "localparam foo = 0;\n"
+       "localparam barrrr = 0;\n"
+       "endmodule\n",
+       "module m #(\n"
+       "    int W = 2,\n"
+       "    int LLLL = 4\n"
+       ");\n"
+       "  localparam foo    = 0;\n"
+       "  localparam barrrr = 0;\n"
+       "endmodule\n"},
+  };
+  // formal kPreserve + body kAlign
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+    style.formal_parameters_alignment = AlignmentPolicy::kPreserve;
+    const auto &tc = kTestCases[0];
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+  // formal kAlign + body kPreserve
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.parameter_declaration_alignment = AlignmentPolicy::kPreserve;
+    style.formal_parameters_alignment = AlignmentPolicy::kAlign;
+    const auto &tc = kTestCases[1];
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+  // formal kInferUserIntent + body kAlign
+  {
+    FormatStyle style;
+    style.column_limit = 40;
+    style.indentation_spaces = 2;
+    style.wrap_spaces = 4;
+    style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+    style.formal_parameters_alignment = AlignmentPolicy::kInferUserIntent;
+    const auto &tc = kTestCases[2];
+    std::ostringstream stream;
+    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
+  }
+}
+
+// Verify parameter declarations with string, real, and function-call default
+// value types to exercise the ColumnSchemaScanner on non-standard type tokens.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentTypeVariants) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// parameter real type
+       "module m;\n"
+       "parameter real X = 1.0;\n"
+       "parameter real Y_LONG = 2.0;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter real X      = 1.0;\n"
+       "  parameter real Y_LONG = 2.0;\n"
+       "endmodule\n"},
+      {// parameter string type
+       "module m;\n"
+       "parameter string s = \"hello\";\n"
+       "parameter string long_s = \"world\";\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter string s      = \"hello\";\n"
+       "  parameter string long_s = \"world\";\n"
+       "endmodule\n"},
+      {// parameter with function call in default value
+       "module m;\n"
+       "parameter int W = func(1, 2);\n"
+       "parameter int H_LONG = other(3);\n"
+       "endmodule\n",
+       "module m;\n"
+       "  parameter int W      = func(1, 2);\n"
+       "  parameter int H_LONG = other(3);\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify parameter_declaration_alignment kInferUserIntent in package bodies.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPackageInfer) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// flush-left params with small diff: infer aligns
+       "package p;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "endpackage\n",
+       "package p;\n"
+       "  localparam foo  = 1;\n"
+       "  localparam barr = 2;\n"
+       "endpackage\n"},
+      {// pre-aligned params: infer preserves
+       "package p;\n"
+       "localparam foo    = 1;\n"
+       "localparam barr   = 2;\n"
+       "localparam baaaaz = 3;\n"
+       "endpackage\n",
+       "package p;\n"
+       "  localparam foo    = 1;\n"
+       "  localparam barr   = 2;\n"
+       "  localparam baaaaz = 3;\n"
+       "endpackage\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify parameter_declaration_alignment boundary behavior in package bodies.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPackageBoundary) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// blank line breaks alignment group in package
+       "package p;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "\n"
+       "localparam baaaaz = 1;\n"
+       "localparam c = 2;\n"
+       "endpackage\n",
+       "package p;\n"
+       "  localparam foo  = 1;\n"
+       "  localparam barr = 2;\n"
+       "\n"
+       "  localparam baaaaz = 1;\n"
+       "  localparam c      = 2;\n"
+       "endpackage\n"},
+      {// separator comment breaks alignment group in package
+       "package p;\n"
+       "localparam foo = 1;\n"
+       "localparam barr = 2;\n"
+       "// ============\n"
+       "localparam baaaaz = 1;\n"
+       "localparam c = 2;\n"
+       "endpackage\n",
+       "package p;\n"
+       "  localparam foo  = 1;\n"
+       "  localparam barr = 2;\n"
+       "  // ============\n"
+       "  localparam baaaaz = 1;\n"
+       "  localparam c      = 2;\n"
+       "endpackage\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  style.alignment_group_boundary =
+      AlignmentGroupBoundary::kBlankLinesAndSeparatorComments;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify the most common default scenario: both formal_parameters_alignment
+// and parameter_declaration_alignment set to kInferUserIntent.
+TEST(FormatterEndToEndTest, BothParamAlignmentsInferUserIntent) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// both flush-left with small diff: infer aligns both formal and body
+       "module m #(\n"
+       "int W = 2,\n"
+       "int LL = 4\n"
+       ");\n"
+       "localparam foo = 0;\n"
+       "localparam barr = 0;\n"
+       "endmodule\n",
+       "module m #(\n"
+       "    int W  = 2,\n"
+       "    int LL = 4\n"
+       ");\n"
+       "  localparam foo  = 0;\n"
+       "  localparam barr = 0;\n"
+       "endmodule\n"},
+      {// both infer: pre-aligned formal, pre-aligned body preserved
+       "module m #(\n"
+       "int W    = 2,\n"
+       "int LLLL = 4\n"
+       ");\n"
+       "localparam foo    = 0;\n"
+       "localparam barrrr = 0;\n"
+       "endmodule\n",
+       "module m #(\n"
+       "    int W    = 2,\n"
+       "    int LLLL = 4\n"
+       ");\n"
+       "  localparam foo    = 0;\n"
+       "  localparam barrrr = 0;\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent;
+  style.formal_parameters_alignment = AlignmentPolicy::kInferUserIntent;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Verify that a large multi-line comment block between parameter
+// declarations does not crash the formatter.  The tree-unwrapper may
+// produce a partition structure where the comment tokens are absorbed
+// into the following parameter partition, which the alignment code
+// must handle gracefully by skipping alignment for that row.
+TEST(FormatterEndToEndTest, ParamDeclarationAlignmentCommentBlockNoCrash) {
+  // These inputs contain large multi-line comment blocks between
+  // parameter/localparam declarations.  The formatter must not crash
+  // (SIGABRT).  Output correctness is secondary; the formatter may
+  // fall back to preserving the original input when the partition
+  // structure prevents safe alignment.
+  const char *kInputs[] = {
+      "module m;\n"
+      "parameter int W = 8;\n"
+      "// Multi-line comment block\n"
+      "// that spans across\n"
+      "//\n"
+      "// several lines\n"
+      "// of explanatory text\n"
+      "//\n"
+      "// It contains enough\n"
+      "// lines to trigger\n"
+      "// the partition structure\n"
+      "// edge case where\n"
+      "// comment tokens are\n"
+      "// absorbed into the\n"
+      "// following parameter\n"
+      "// partition.\n"
+      "//\n"
+      "localparam int H = 2;\n"
+      "endmodule\n",
+      "package p;\n"
+      "parameter int X = 1;\n"
+      "// Long comment block\n"
+      "// with many lines\n"
+      "//\n"
+      "// of text\n"
+      "//\n"
+      "localparam int Y = 2;\n"
+      "endpackage\n",
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
+  for (const char *input : kInputs) {
+    VLOG(1) << "code-to-format:\n" << input << "<EOF>";
+    std::ostringstream stream;
+    const auto status = FormatVerilog(input, "<filename>", style, stream);
+    // The primary requirement is that the formatter does not crash
+    // (SIGABRT).  Gtest will report failure if the process aborts.
+    // The partition structure may cause output format differences;
+    // the important thing is the formatter handled it gracefully.
+  }
+}
+
+}  // namespace
+}  // namespace formatter
+}  // namespace verilog
diff --git a/verible/verilog/formatting/formatter_class_package_test.cc b/verible/verilog/formatting/formatter_class_package_test.cc
new file mode 100644
index 0000000..0c5e067
--- /dev/null
+++ b/verible/verilog/formatting/formatter_class_package_test.cc
@@ -0,0 +1,974 @@
+// Copyright 2017-2026 The Verible Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Test cases in this file should be *insensitive* to wrapping penalties.
+// Penalty-sensitive tests belong in formatter-tuning_test.cc.
+
+#include "gtest/gtest.h"
+#include "verible/verilog/formatting/formatter-test-utils.h"
+
+namespace verilog {
+namespace formatter {
+namespace {
+
+static constexpr FormatterTestCase kClassPackageFormatterTestCases[] = {
+    // interface test cases
+    {// two interface declarations
+     " interface if1 ; endinterface\t\t"
+     "interface  if2; endinterface   ",
+     "interface if1;\n"
+     "endinterface\n"
+     "interface if2;\n"
+     "endinterface\n"},
+    {// two interface declarations, end labels
+     " interface if1 ; endinterface:if1\t\t"
+     "interface  if2; endinterface    :  if2   ",
+     "interface if1;\n"
+     "endinterface : if1\n"
+     "interface if2;\n"
+     "endinterface : if2\n"},
+    {// interface declaration with parameters
+     " interface if1#( parameter int W= 8 );endinterface\t\t",
+     "interface if1 #(\n"
+     "    parameter int W = 8\n"
+     ");\n"
+     "endinterface\n"},
+    {// interface declaration with ports (empty)
+     " interface if1()\n;endinterface\t\t",
+     "interface if1 ();\n"
+     "endinterface\n"},
+    {// interface declaration with parameter comment only, empty ports
+     " interface if1#( \n"
+     "//param\n"
+     ")();endinterface\t\t",
+     "interface if1 #(\n"
+     "    //param\n"
+     ") ();\n"
+     "endinterface\n"},
+    {// interface declaration with parameter, empty ports
+     " interface if1#( parameter int W= 8 )();endinterface\t\t",
+     "interface if1 #(\n"
+     "    parameter int W = 8\n"
+     ") ();\n"
+     "endinterface\n"},
+    {// interface declaration with ports
+     " interface if1( input\tlogic   z)\n;endinterface\t\t",
+     "interface if1 (\n"
+     "    input logic z\n"
+     ");\n"
+     "endinterface\n"},
+    {// interface declaration with multiple ports
+     " interface if1( input\tlogic   z, output logic a)\n;endinterface\t\t",
+     "interface if1 (\n"
+     "    input  logic z,\n"  // should be one-per-line, even it it fits
+     "    output logic a\n"   // aligned
+     ");\n"
+     "endinterface\n"},
+    {// interface declaration with parameters and ports
+     " interface if1#( parameter int W= 8 )(input logic z);endinterface\t\t",
+     // doesn't fit on one line
+     "interface if1 #(\n"
+     "    parameter int W = 8\n"
+     ") (\n"
+     "    input logic z\n"
+     ");\n"
+     "endinterface\n"},
+    {
+        // interface with modport declarations
+        "interface\tfoo_if  ;"
+        "modport  mp1\t( output a, input b);"
+        "modport\tmp2  (output c,input d );\t"
+        "endinterface",
+        "interface foo_if;\n"
+        "  modport mp1(output a, input b);\n"
+        "  modport mp2(output c, input d);\n"
+        "endinterface\n",
+    },
+    {
+        // interface with long modport port names
+        "interface\tfoo_if  ;"
+        "modport  mp1\t( output a_long_output, input detailed_input_name);"
+        "endinterface",
+        "interface foo_if;\n"
+        "  modport mp1(\n"
+        "      output a_long_output,\n"
+        "      input detailed_input_name\n"
+        "  );\n"
+        "endinterface\n",
+    },
+    {
+        // interface with modport declaration with multiple ports
+        "interface\tfoo_if  ;"
+        "modport  mp1\t( output a_long_output, input detailed_input_name);"
+        "endinterface",
+        "interface foo_if;\n"
+        "  modport mp1(\n"
+        "      output a_long_output,\n"
+        "      input detailed_input_name\n"
+        "  );\n"
+        "endinterface\n",
+    },
+    {
+        // interface with modport TF port declaration
+        "interface\tfoo_if  ;"
+        "modport  mp1\t( output a, input b, import c);"
+        "endinterface",
+        "interface foo_if;\n"
+        "  modport mp1(\n"
+        "      output a,\n"
+        "      input b,\n"
+        "      import c\n"
+        "  );\n"
+        "endinterface\n",
+    },
+    {
+        // interface with complex modport ports list
+        "interface\tfoo_if  ;"
+        "modport producer\t(input ready,\toutput data, valid, user,"
+        " strobe, keep, last,\timport producer_reset, producer_tick);"
+        "modport consumer\t(input data, valid, user, strobe, keep, last,"
+        " output ready,\timport consumer_reset, consumer_tick, consume);"
+        "endinterface",
+        "interface foo_if;\n"
+        "  modport producer(\n"
+        "      input ready,\n"
+        "      output data, valid, user, strobe,\n"
+        "          keep, last,\n"
+        "      import producer_reset,\n"
+        "          producer_tick\n"
+        "  );\n"
+        "  modport consumer(\n"
+        "      input data, valid, user, strobe,\n"
+        "          keep, last,\n"
+        "      output ready,\n"
+        "      import consumer_reset,\n"
+        "          consumer_tick, consume\n"
+        "  );\n"
+        "endinterface\n",
+    },
+    {
+        // interface with modports and comments inside
+        "interface foo_if;\n"
+        " modport mp1(\n"
+        "  // Our output\n"
+        "     output a,\n"
+        "  /* Inputs */\n"
+        "      input b1, b_f /*last*/,"
+        "  import c\n"
+        "  );\n"
+        "endinterface\n",
+        "interface foo_if;\n"
+        "  modport mp1(\n"
+        "      // Our output\n"
+        "      output a,\n"
+        "      /* Inputs */\n"
+        "      input b1, b_f  /*last*/,\n"
+        "      import c\n"
+        "  );\n"
+        "endinterface\n",
+    },
+
+    // class test cases
+    {"class action;int xyz;endclass  :  action\n",
+     "class action;\n"
+     "  int xyz;\n"
+     "endclass : action\n"},
+    {"class action  extends mypkg :: inaction;endclass  :  action\n",
+     "class action extends mypkg::inaction;\n"  // tests for spacing around ::
+     "endclass : action\n"},
+    {"class c;function new;endfunction endclass",
+     "class c;\n"
+     "  function new;\n"
+     "  endfunction\n"
+     "endclass\n"},
+    {"class c;function new ( );endfunction endclass",
+     "class c;\n"
+     "  function new();\n"
+     "  endfunction\n"
+     "endclass\n"},
+    {"class c;function new ( string s );endfunction endclass",
+     "class c;\n"
+     "  function new(string s);\n"
+     "  endfunction\n"
+     "endclass\n"},
+    {"class c;function new ( string s ,int i );endfunction endclass",
+     "class c;\n"
+     "  function new(string s, int i);\n"
+     "  endfunction\n"
+     "endclass\n"},
+    {"class c;function void f;endfunction endclass",
+     "class c;\n"
+     "  function void f;\n"
+     "  endfunction\n"
+     "endclass\n"},
+    {"class c;virtual function void f;endfunction endclass",
+     "class c;\n"
+     "  virtual function void f;\n"
+     "  endfunction\n"
+     "endclass\n"},
+    {"class c;function int f ( );endfunction endclass",
+     "class c;\n"
+     "  function int f();\n"
+     "  endfunction\n"
+     "endclass\n"},
+    {"class c;function int f ( int  ii );endfunction endclass",
+     "class c;\n"
+     "  function int f(int ii);\n"
+     "  endfunction\n"
+     "endclass\n"},
+    {"class c;function int f ( int  ii ,bit  bb );endfunction endclass",
+     "class c;\n"
+     "  function int f(int ii, bit bb);\n"
+     "  endfunction\n"
+     "endclass\n"},
+    {"class c;task t ;endtask endclass",
+     "class c;\n"
+     "  task t;\n"
+     "  endtask\n"
+     "endclass\n"},
+    {"class c;task t ( int  ii ,bit  bb );endtask endclass",
+     "class c;\n"
+     "  task t(int ii, bit bb);\n"
+     "  endtask\n"
+     "endclass\n"},
+    {"class c; task automatic repeated_assigner;"
+     "repeat (count) y = w;"  // single statement body
+     "endtask endclass",
+     "class c;\n"
+     "  task automatic repeated_assigner;\n"
+     "    repeat (count) y = w;\n"
+     "  endtask\n"
+     "endclass\n"},
+    {"class c; task automatic delayed_assigner;"
+     "#   100   y = w;"  // delayed assignment
+     "endtask endclass",
+     "class c;\n"
+     "  task automatic delayed_assigner;\n"
+     "    #100 y = w;\n"
+     "  endtask\n"
+     "endclass\n"},
+    {"class c; task automatic labeled_assigner;"
+     "lbl   :   y = w;"  // delayed assignment
+     "endtask endclass",
+     "class c;\n"
+     "  task automatic labeled_assigner;\n"
+     "    lbl : y = w;\n"  // TODO(fangism): no space before ':'
+     "  endtask\n"
+     "endclass\n"},
+    // task with macro call
+    {"module m1;\ntask automatic t1();\n"
+     "t2(`R1(1)+ 8);endtask : t1\nendmodule",
+     "module m1;\n"
+     "  task automatic t1();\n"
+     "    t2(`R1(1) + 8);\n"
+     "  endtask : t1\n"
+     "endmodule\n"},
+
+    // tasks with control statements
+    {"class c; task automatic waiter;"
+     "if (count == 0) begin #0; return;end "
+     "endtask endclass",
+     "class c;\n"
+     "  task automatic waiter;\n"
+     "    if (count == 0) begin\n"
+     "      #0;\n"
+     "      return;\n"
+     "    end\n"
+     "  endtask\n"
+     "endclass\n"},
+    {"class c; task automatic heartbreaker;"
+     "if( c)if( d) break ;"
+     "endtask endclass",
+     "class c;\n"
+     "  task automatic heartbreaker;\n"
+     "    if (c) if (d) break;\n"
+     "  endtask\n"
+     "endclass\n"},
+    {"class c; task automatic waiter;"
+     "repeat (count) @(posedge clk);"
+     "endtask endclass",
+     "class c;\n"
+     "  task automatic waiter;\n"
+     "    repeat (count) @(posedge clk);\n"
+     "  endtask\n"
+     "endclass\n"},
+    {"class c; task automatic repeat_assigner;"
+     "repeat( r )\ny = w;"
+     "repeat( q )\ny = 1;"
+     "endtask endclass",
+     "class c;\n"
+     "  task automatic repeat_assigner;\n"
+     "    repeat (r) y = w;\n"
+     "    repeat (q) y = 1;\n"
+     "  endtask\n"
+     "endclass\n"},
+    {"class c; task automatic event_control_assigner;"
+     "@ ( posedge clk )\ny = w;"
+     "@ ( negedge clk )\nz = w;"
+     "endtask endclass",
+     "class c;\n"
+     "  task automatic event_control_assigner;\n"
+     "    @(posedge clk) y = w;\n"
+     "    @(negedge clk) z = w;\n"
+     "  endtask\n"
+     "endclass\n"},
+    {
+        // classes with surrrounding comments
+        // vertical spacing preserved
+        "\n// pre-c\n\n"
+        "  class   c  ;\n"
+        "// c stuff\n"
+        "endclass\n"
+        "  // pre-d\n"
+        "\n\nclass d ;\n"
+        " // d stuff\n"
+        "endclass\n"
+        "\n// the end\n",
+        "\n// pre-c\n\n"
+        "class c;\n"
+        "  // c stuff\n"
+        "endclass\n"
+        "// pre-d\n\n\n"
+        "class d;\n"
+        "  // d stuff\n"
+        "endclass\n\n"
+        "// the end\n",
+    },
+    {// class with comments around task/function declarations
+     "class c;      // c is for cookie\n"
+     "    // f is for false\n"
+     "\tfunction f(integer size) ; endfunction\n"
+     " // t is for true\n"
+     "task t();endtask\n"
+     " // class is about to end\n"
+     "endclass",
+     "class c;  // c is for cookie\n"
+     "  // f is for false\n"
+     "  function f(integer size);\n"
+     "  endfunction\n"
+     "  // t is for true\n"
+     "  task t();\n"
+     "  endtask\n"
+     "  // class is about to end\n"
+     "endclass\n"},
+
+    // interface class test cases
+    {"interface class Foo;\nendclass\n",
+     "interface class Foo;\n"
+     "endclass\n"},
+    {"interface   class   Foo  ;  endclass\n",
+     "interface class Foo;\n"
+     "endclass\n"},
+    {"interface class Foo extends Bar , Baz ;\nendclass\n",
+     "interface class Foo extends Bar, Baz;\n"
+     "endclass\n"},
+    {"interface class Foo;\n  pure   virtual   task   foo (  ) ; \nendclass\n",
+     "interface class Foo;\n"
+     "  pure virtual task foo();\n"
+     "endclass\n"},
+
+    // class property alignment test cases
+    {"class c;\n"
+     "int foo  ;\n"
+     "byte bar;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  int  foo;\n"
+     "  byte bar;\n"
+     "endclass : c\n"},
+    {"class c;\n"
+     "int foo;\n"
+     "const bit b;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  int       foo;\n"
+     "  const bit b;\n"
+     "endclass : c\n"},
+    {"class c;\n"
+     "rand logic l;\n"
+     "int foo;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  rand logic l;\n"
+     "  int        foo;\n"
+     "endclass : c\n"},
+    {"class c;\n"
+     "rand logic l;\n"
+     "const static int foo;\n"  // more qualifiers
+     "endclass : c\n",
+     "class c;\n"
+     "  rand logic       l;\n"
+     "  const static int foo;\n"
+     "endclass : c\n"},
+    {"class c;\n"
+     "static local int foo;\n"
+     "const bit b;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  static local int foo;\n"
+     "  const bit        b;\n"
+     "endclass : c\n"},
+    {// example with queue
+     "class c;\n"
+     "int foo [$] ;\n"
+     "int foo_bar ;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  int foo     [$];\n"
+     "  int foo_bar;\n"
+     "endclass : c\n"},
+    {// subcolumns
+     "class cc;\n"
+     "rand bit [A-1:0] foo;\n"
+     "rand bit [A-1:0][2] bar;\n"
+     "int foobar[X+1:Y];\n"
+     "int baz[42];\n"
+     "rand bit qux[Z];\n"
+     "rand bit [1:0] quux[3:0];\n"
+     "rand bit [A:BB][42] quuz[7];\n"
+     "endclass\n",
+     "class cc;\n"
+     "  rand bit [A-1: 0]     foo;\n"
+     "  rand bit [A-1: 0][ 2] bar;\n"
+     "  int                   foobar[X+1:Y];\n"
+     "  int                   baz   [   42];\n"
+     "  rand bit              qux   [    Z];\n"
+     "  rand bit [  1: 0]     quux  [  3:0];\n"
+     "  rand bit [  A:BB][42] quuz  [    7];\n"
+     "endclass\n"},
+    {"class cc;\n"
+     "int qux[2];\n"
+     "int quux[SIZE-1+SHIFT:SHIFT];\n"
+     "int quuz[SOME_CONSTANT];\n"
+     "endclass\n",
+     "class cc;\n"
+     "  int qux [                 2];\n"
+     "  int quux[SIZE-1+SHIFT:SHIFT];\n"
+     "  int quuz[     SOME_CONSTANT];\n"
+     "endclass\n"},
+    {// aligns over comments (ignored)
+     "class c;\n"
+     "// foo is...\n"
+     "int foo;\n"
+     "// b is...\n"
+     "const bit b;\n"
+     " // llama is...\n"
+     "logic llama;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  // foo is...\n"
+     "  int       foo;\n"
+     "  // b is...\n"
+     "  const bit b;\n"
+     "  // llama is...\n"
+     "  logic     llama;\n"
+     "endclass : c\n"},
+    {// aligns over comments (ignored), even with blank lines
+     "class c;\n"
+     "// foo is...\n"
+     "int foo;\n"
+     "\n"
+     "// b is...\n"
+     "const bit b;\n"
+     "\n"
+     " // llama is...\n"
+     "logic llama;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  // foo is...\n"
+     "  int       foo;\n"
+     "\n"
+     "  // b is...\n"
+     "  const bit b;\n"
+     "\n"
+     "  // llama is...\n"
+     "  logic     llama;\n"
+     "endclass : c\n"},
+    {"class c;\n"
+     "rand logic l;\n"
+     "int [1:0] foo;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  rand logic       l;\n"
+     "  int        [1:0] foo;\n"
+     "endclass : c\n"},
+    {// non-data-declarations break up groups
+     "class c;\n"
+     "rand logic l;\n"
+     "int foo;\n"
+     "`uvm_bar_foo()\n"
+     "logic k;\n"
+     "rand int bar;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  rand logic l;\n"
+     "  int        foo;\n"
+     "  `uvm_bar_foo()\n"  // separates alignment groups above/below
+     "  logic    k;\n"
+     "  rand int bar;\n"
+     "endclass : c\n"},
+    {// non-data-declarations break up groups
+     "class c;\n"
+     "logic k;\n"
+     "rand int bar;\n"
+     "function void f();\n"
+     "endfunction\n"
+     "rand logic l;\n"
+     "int foo;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  logic    k;\n"
+     "  rand int bar;\n"
+     "  function void f();\n"  // function declaration breaks groups
+     "  endfunction\n"
+     "  rand logic l;\n"
+     "  int        foo;\n"
+     "endclass : c\n"},
+    {// align single-value initializers at the '='
+     "class c;\n"
+     "const logic foo=0;\n"
+     "const bit b=1;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  const logic foo = 0;\n"
+     "  const bit   b   = 1;\n"
+     "endclass : c\n"},
+    {// align single-value initializers at the '=', over non-initialized
+     "class c;\n"
+     "const logic foo=0;\n"
+     "rand int iidrv;\n"
+     "const bit b=1;\n"
+     "endclass : c\n",
+     "class c;\n"
+     "  const logic foo    = 0;\n"
+     "  rand int    iidrv;\n"  // no initializer, but align across this
+     "  const bit   b      = 1;\n"
+     "endclass : c\n"},
+
+    // constraint test cases
+    {
+        "class foo; constraint c1_c{ } endclass",
+        "class foo;\n"
+        "  constraint c1_c {}\n"
+        "endclass\n",
+    },
+    {
+        "class foo; constraint c1_c{  } constraint c2_c{ } endclass",
+        "class foo;\n"
+        "  constraint c1_c {}\n"
+        "  constraint c2_c {}\n"
+        "endclass\n",
+    },
+    {
+        "class foo; constraint c1_c{soft z==y;unique{baz};}endclass",
+        "class foo;\n"
+        "  constraint c1_c {\n"
+        "    soft z == y;\n"
+        "    unique {baz};\n"
+        "  }\n"
+        "endclass\n",
+    },
+    {
+        "class foo; constraint c1_c{ //comment1\n"
+        "//comment2\n"
+        "//comment3\n"
+        "} endclass",
+        "class foo;\n"
+        "  constraint c1_c {  //comment1\n"
+        "    //comment2\n"
+        "    //comment3\n"
+        "  }\n"
+        "endclass\n",
+    },
+
+    {"class foo;constraint c { "
+     "timer_enable dist { [ 8'h0 : 8'hfe ] :/ 90 , 8'hff :/ 10 }; "
+     "} endclass\n",
+     "class foo;\n"
+     "  constraint c {\n"
+     "    timer_enable dist {\n"
+     "      [8'h0 : 8'hfe] :/ 90,\n"
+     "      8'hff          :/ 10\n"  // aligned
+     "    };\n"
+     "  }\n"
+     "endclass\n"},
+
+    {
+        "class Foo; constraint if_c { if (z) { soft x == y; } } endclass\n",
+        "class Foo;\n"
+        "  constraint if_c {\n"
+        "    if (z) {\n"
+        "      soft x == y;\n"
+        "    }\n"
+        "  }\n"
+        "endclass\n",
+    },
+    {
+        "class Foo; constraint if_c { if (z) {\n"
+        "//comment-a\n"
+        "soft x == y;\n"
+        "//comment-b\n"
+        "} } endclass\n",
+        "class Foo;\n"
+        "  constraint if_c {\n"
+        "    if (z) {\n"
+        "      //comment-a\n"  // properly indented
+        "      soft x == y;\n"
+        "      //comment-b\n"  // properly indented
+        "    }\n"
+        "  }\n"
+        "endclass\n",
+    },
+    {
+        "class c; "
+        "constraint c_has_config_error {"
+        "if (yyy) {zzzz == 1;} else {yyyyyyy == 0;}} "
+        "endclass",
+        "class c;\n"
+        "  constraint c_has_config_error {\n"
+        "    if (yyy) {\n"
+        "      zzzz == 1;\n"
+        "    } else {\n"
+        "      yyyyyyy == 0;\n"
+        "    }\n"
+        "  }\n"
+        "endclass\n",
+    },
+    // distributions: colon alignment
+    {"class c;\n"
+     "constraint co {\n"
+     "d dist {\n"
+     "[1:2]:/2,\n"
+     "[11:33]:/22,\n"
+     "[111:444]:/8,\n"
+     "[1:42]:/10,\n"
+     "[11:12]:/3\n"
+     "};\n"
+     "}\n"
+     "endclass\n",
+     "class c;\n"
+     "  constraint co {\n"
+     "    d dist {\n"
+     "      [  1 :   2] :/ 2,\n"
+     "      [ 11 :  33] :/ 22,\n"
+     "      [111 : 444] :/ 8,\n"
+     "      [  1 :  42] :/ 10,\n"
+     "      [ 11 :  12] :/ 3\n"
+     "    };\n"
+     "  }\n"
+     "endclass\n"},
+    // distributions: subcolumns
+    {"class foo;\n"
+     "constraint bar {\n"
+     "baz dist {\n"
+     "[1:2]:/2,\n"
+     "QUX[3:0]:/10,\n"
+     "[11:33]:/22,\n"
+     "ID_LONGER_THAN_RANGES:/3,\n"
+     "[111:QUUZ[Z]]:/8,\n"
+     "[X[4:0]:Y[8:Z-2]]:/8\n"
+     "};\n"
+     "}\n"
+     "endclass\n",
+     "class foo;\n"
+     "  constraint bar {\n"
+     "    baz dist {\n"
+     "      [     1 :        2]   :/ 2,\n"
+     "      QUX[3:0]              :/ 10,\n"
+     "      [    11 :       33]   :/ 22,\n"
+     "      ID_LONGER_THAN_RANGES :/ 3,\n"
+     "      [   111 :  QUUZ[Z]]   :/ 8,\n"
+     "      [X[4:0] : Y[8:Z-2]]   :/ 8\n"
+     "    };\n"
+     "  }\n"
+     "endclass\n"},
+    // class with empty parameter list
+    {"class foo #(); endclass",
+     "class foo #();\n"
+     "endclass\n"},
+    // class with empty parameter list, with comment
+    {"class foo #(  \n"
+     "// comment\n"
+     "); endclass",
+     "class foo #(\n"
+     "    // comment\n"
+     ");\n"
+     "endclass\n"},
+    // class with empty parameter list, extends
+    {"class foo #()extends bar ; endclass",
+     "class foo #() extends bar;\n"
+     "endclass\n"},
+    // class extends from type with named parameters
+    {"class foo extends bar #(.N(N), .M(M)); endclass",
+     "class foo extends bar #(\n"
+     "    .N(N),\n"
+     "    .M(M)\n"
+     ");\n"
+     "endclass\n"},
+
+    // class with one parameter list
+    {"class foo #(type a = b); endclass",
+     "class foo #(\n"
+     "    type a = b\n"
+     ");\n"
+     "endclass\n"},
+
+    // class with multiple paramter list
+    {"class foo #(type a = b, type c = d, type e = f); endclass",
+     "class foo #(\n"
+     "    type a = b,\n"
+     "    type c = d,\n"
+     "    type e = f\n"
+     ");\n"
+     "endclass\n"},
+
+    // class with data members
+    {"class  i_love_data ;const\ninteger  sizer\t;endclass",
+     "class i_love_data;\n"
+     "  const integer sizer;\n"
+     "endclass\n"},
+    {"class  i_love_data ;const\ninteger  sizer=3\t;endclass",
+     "class i_love_data;\n"
+     "  const integer sizer = 3;\n"
+     "endclass\n"},
+    {"class  i_love_data ;protected\nint  count  \t;endclass",
+     "class i_love_data;\n"
+     "  protected int count;\n"
+     "endclass\n"},
+    {"class  i_love_data ;\t\nint  counter\n ;int  countess \t;endclass",
+     "class i_love_data;\n"
+     "  int counter;\n"
+     "  int countess;\n"
+     "endclass\n"},
+    {"class  i_love_params ;foo#( . bar)  baz\t;endclass",
+     "class i_love_params;\n"
+     "  foo #(.bar) baz;\n"
+     "endclass\n"},
+    {"class  i_love_params ;foo#( . bar ( bah ))  baz\t;endclass",
+     "class i_love_params;\n"
+     "  foo #(.bar(bah)) baz;\n"
+     "endclass\n"},
+    {"class  i_love_params ;foo#( . bar ( bah\n),"
+     ".\ncat( dog) )  baz\t;endclass",
+     "class i_love_params;\n"
+     "  foo #(\n"
+     "      .bar(bah),\n"
+     "      .cat(dog)\n"
+     "  ) baz;\n"
+     "endclass\n"},
+    {"class  i_love_params ;foo#( . bar)  baz1,baz2\t;endclass",
+     "class i_love_params;\n"
+     "  foo #(.bar) baz1, baz2;\n"
+     "endclass\n"},
+    {"class  i_love_params ;foo#( . bar)  baz\t;baz#(.foo)bar;endclass",
+     "class i_love_params;\n"
+     "  foo #(.bar) baz;\n"
+     "  baz #(.foo) bar;\n"
+     "endclass\n"},
+    {"class i_love_params // comment\n"
+     ";\n"
+     "foo#(\n"
+     ".foobar(quuuuux) // comment\n"
+     ", .cat(dog)\n"
+     ") baz // comment\n"
+     ";endclass\n",
+     "class i_love_params  // comment\n"
+     ";\n"
+     "  foo #(\n"
+     "        .foobar(quuuuux)  // comment\n"
+     "      , .cat   (dog)\n"
+     "  ) baz  // comment\n"
+     "  ;\n"
+     "endclass\n"},
+
+    // typedef test cases
+    {"typedef enum logic\t{ A=0, B=1 }foo_t;",
+     "typedef enum logic {\n"
+     "  A = 0,\n"
+     "  B = 1\n"
+     "} foo_t;\n"},
+    {"typedef enum uint8_t\t{ kA=8'b0, kB=8'b1 }foo_t;",
+     "typedef enum uint8_t {\n"  // uint8_t is user-defined
+     "  kA = 8'b0,\n"
+     "  kB = 8'b1\n"
+     "} foo_t;\n"},
+    {// With comments on same line as enum value
+     "typedef enum logic\t{ A=0, // foo\n"
+     "B,// bar\n"
+     "`ifndef DO_PANIC\n"
+     "C=42,// answer\n"
+     "`endif\n"
+     "D=3    // baz\n"
+     "}foo_t;",
+     "typedef enum logic {\n"
+     "  A = 0,   // foo\n"
+     "  B,       // bar\n"
+     "`ifndef DO_PANIC\n"
+     "  C = 42,  // answer\n"
+     "`endif\n"
+     "  D = 3    // baz\n"
+     "} foo_t;\n"},
+    {// with scalar dimensions
+     "typedef enum logic[2]\t{ A=0, B=1 }foo_t;",
+     "typedef enum logic [2] {\n"
+     "  A = 0,\n"
+     "  B = 1\n"
+     "} foo_t;\n"},
+    {// with range dimensions
+     "typedef enum logic[1:0]\t{ A=0, B=1 }foo_t;",
+     "typedef enum logic [1:0] {\n"
+     "  A = 0,\n"
+     "  B = 1\n"
+     "} foo_t;\n"},
+    {"typedef foo_pkg::baz_t#(.L(L), .W(W)) bar_t;\n",
+     "typedef foo_pkg::baz_t#(\n"
+     "    .L(L),\n"
+     "    .W(W)\n"
+     ") bar_t;\n"},
+    // By default (class_parameter_space == false), no space before '#'
+    {"typedef dv_base_env_cov #(.CFG_T(tl_agent_env_cfg)) tl_agent_env_cov;\n",
+     "typedef dv_base_env_cov#(\n"
+     "    .CFG_T(tl_agent_env_cfg)\n"
+     ") tl_agent_env_cov;\n"},
+    {"typedef dv_base_env_cov#(.CFG_T(tl_agent_env_cfg)) tl_agent_env_cov;\n",
+     "typedef dv_base_env_cov#(\n"
+     "    .CFG_T(tl_agent_env_cfg)\n"
+     ") tl_agent_env_cov;\n"},
+    // single short parameter stays on one line
+    {"typedef my_class #(.P(P)) my_class_t;\n",
+     "typedef my_class#(.P(P)) my_class_t;\n"},
+
+    // let declarations each stay on their own line
+    {"module t;\n"
+     "let OFF = 4;\n"
+     "let UNIQUE = 32;\n"
+     "let PP(a) = 30 + a;\n"
+     "endmodule\n",
+     "module t;\n"
+     "  let OFF = 4;\n"
+     "  let UNIQUE = 32;\n"
+     "  let PP(a) = 30 + a;\n"
+     "endmodule\n"},
+
+    // let declarations each stay on their own line
+    {"module t;\n"
+     "let OFF = 4;\n"
+     "let UNIQUE = 32;\n"
+     "let PP(a) = 30 + a;\n"
+     "endmodule\n",
+     "module t;\n"
+     "  let OFF = 4;\n"
+     "  let UNIQUE = 32;\n"
+     "  let PP(a) = 30 + a;\n"
+     "endmodule\n"},
+
+    // package test cases
+    {"package fedex;localparam  int  www=3 ;endpackage   :  fedex\n",
+     "package fedex;\n"
+     "  localparam int www = 3;\n"
+     "endpackage : fedex\n"},
+    {"package   typey ;"
+     "typedef enum int{ A=0, B=1 }foo_t;"
+     "typedef enum{ C=0, D=1 }bar_t;"
+     "endpackage:typey\n",
+     "package typey;\n"
+     "  typedef enum int {\n"
+     "    A = 0,\n"
+     "    B = 1\n"
+     "  } foo_t;\n"
+     "  typedef enum {\n"
+     "    C = 0,\n"
+     "    D = 1\n"
+     "  } bar_t;\n"
+     "endpackage : typey\n"},
+    {// net type declarations
+     "package foo_pkg;"
+     "nettype shortreal\t\tfoo  ;"
+     "nettype\nbar[1:0 ] baz  with\tquux ;"
+     "endpackage",
+     "package foo_pkg;\n"
+     "  nettype shortreal foo;\n"
+     "  nettype bar [1:0] baz with quux;\n"
+     "endpackage\n"},
+    {"package foo_pkg; \n"
+     "// function description.......\n"
+     "function automatic void bar();"
+     "endfunction "
+     "endpackage\n",
+     "package foo_pkg;\n"
+     "  // function description.......\n"
+     "  function automatic void bar();\n"
+     "  endfunction\n"
+     "endpackage\n"},
+    {"package foo_pkg; \n"
+     "// function description.......\n"
+     "function void bar(string name=\"x\" ) ;"
+     "endfunction "
+     "endpackage\n",
+     "package foo_pkg;\n"
+     "  // function description.......\n"
+     "  function void bar(string name = \"x\");\n"
+     "  endfunction\n"
+     "endpackage\n"},
+    {" package foo_pkg; \n"
+     "// class description.............\n"
+     "class classy;"
+     "endclass "
+     "endpackage\n",
+     "package foo_pkg;\n"
+     "  // class description.............\n"
+     "  class classy;\n"
+     "  endclass\n"
+     "endpackage\n"},
+    {"package\tfoo_pkg; \n"
+     "// class description.............\n"
+     "class   classy;    \n"
+     "// function description.......\n"
+     "function\nautomatic   void bar( );"
+     "endfunction   "
+     "endclass\t"
+     "endpackage\n",
+     "package foo_pkg;\n"
+     "  // class description.............\n"
+     "  class classy;\n"
+     "    // function description.......\n"
+     "    function automatic void bar();\n"
+     "    endfunction\n"
+     "  endclass\n"
+     "endpackage\n"},
+    {"package fedex;\n"
+     "  import \"asdf\" context function void bar(\n"
+     "    input bit              [2:1] aaaa,   // EOL COMMENT\n"
+     "                                          // another\n"
+     "    input bit foo\n"
+     "  );\n"
+     "endpackage\n",
+     "package fedex;\n"
+     "  import \"asdf\" context\n"
+     "      function void bar(\n"
+     "    input\n        bit [2:1] aaaa,  // EOL COMMENT\n"
+     "                         // another\n"
+     "    input bit foo\n"
+     "  );\n"
+     "endpackage\n"},
+
+};
+
+TEST(FormatterEndToEndTest, ClassPackageFormatterTestCases) {
+  RunFormatterTestCases40(kClassPackageFormatterTestCases);
+}
+
+}  // namespace
+}  // namespace formatter
+}  // namespace verilog
diff --git a/verible/verilog/formatting/formatter_disable_test.cc b/verible/verilog/formatting/formatter_disable_test.cc
new file mode 100644
index 0000000..b653063
--- /dev/null
+++ b/verible/verilog/formatting/formatter_disable_test.cc
@@ -0,0 +1,5814 @@
+// Copyright 2017-2026 The Verible Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Test cases in this file should be *insensitive* to wrapping penalties.
+// Penalty-sensitive tests belong in formatter-tuning_test.cc.
+
+#include "gtest/gtest.h"
+#include "verible/verilog/formatting/formatter-test-utils.h"
+
+namespace verilog {
+namespace formatter {
+namespace {
+
+static constexpr FormatterTestCase kDisableFormatterTestCases[] = {
+    // comment-controlled formatter disabling
+    {"// verilog_format: off\n"  // disables whole file
+     "  `include  \t\t  \"path/to/file.vh\"\n",
+     "// verilog_format: off\n"
+     "  `include  \t\t  \"path/to/file.vh\"\n"},  // keeps bad spacing
+    {"/* verilog_format: off */\n"                // disables whole file
+     "  `include  \t\t  \"path/to/file.svh\"  \n",
+     "/* verilog_format: off */\n"
+     "  `include  \t\t  \"path/to/file.svh\"  \n"},  // keeps bad spacing
+    {"// verilog_format: on\n"  // already enabled, no effect
+     "  `include  \t  \"path/to/file.svh\"  \t\n",
+     "// verilog_format: on\n"
+     "`include \"path/to/file.svh\"\n"},
+    {"// verilog_format: off\n"
+     "// verilog_format: on\n"  // re-enable right away
+     "  `include  \t\t  \"path/to/file.svh\"  \n",
+     "// verilog_format: off\n"
+     "// verilog_format: on\n"
+     "`include \"path/to/file.svh\"\n"},
+    {"/* aaa *//* bbb */\n"                         // not formatting controls
+     "  `include  \t\t  \"path/to/file.svh\"  \n",  // should format
+     "/* aaa */  /* bbb */\n"  // currently inserts 2 spaces
+     "`include \"path/to/file.svh\"\n"},
+    {"/* verilog_format: off *//* verilog_format: on */\n"  // re-enable
+     "  `include  \t\t  \"path/to/file.svh\"  \n",
+     // Note that this case normally wouldn't fit in 40 columns,
+     // but disabling formatting lets it overflow.
+     "/* verilog_format: off *//* verilog_format: on */\n"
+     "`include \"path/to/file.svh\"\n"},
+    {"// verilog_format: off\n"
+     "  `include  \t\t  \"path/to/fileA.svh\"  // verilog_format: on\n"
+     "  `include  \t\t  \"path/to/fileB.svh\"  \n",
+     // re-enable formatting with comment trailing other tokens
+     "// verilog_format: off\n"
+     "  `include  \t\t  \"path/to/fileA.svh\"  // verilog_format: on\n"
+     "`include \"path/to/fileB.svh\"\n"},
+    {"  `include  \t\t  \"path/to/file1.vh\" \n"  // format this
+     "// verilog_format: off\n"                   // start disabling
+     "  `include  \t\t  \"path/to/file2.vh\" \n"
+     "\t\t\n"
+     "  `include  \t\t  \"path/to/file3.vh\" \n"
+     "// verilog_format: on\n"                     // stop disabling
+     "  `include  \t\t  \"path/to/file4.vh\" \n",  // format this
+     "`include \"path/to/file1.vh\"\n"
+     "// verilog_format: off\n"  // start disabling
+     "  `include  \t\t  \"path/to/file2.vh\" \n"
+     "\t\t\n"
+     "  `include  \t\t  \"path/to/file3.vh\" \n"
+     "// verilog_format: on\n"  // stop disabling
+     "`include \"path/to/file4.vh\"\n"},
+    {// disabling formatting on a module (to end of file)
+     "// verilog_format: off\n"
+     "module m;endmodule\n",
+     "// verilog_format: off\n"
+     "module m;endmodule\n"},
+    {// disabling formatting on a module (to end of file)
+     "// verilog_format: off\n"
+     "module m;\n"
+     "unindented instantiation;\n"
+     "endmodule\n",
+     "// verilog_format: off\n"
+     "module m;\n"
+     "unindented instantiation;\n"
+     "endmodule\n"},
+    {// disabling formatting inside a port declaration list disables alignment,
+     // but falls back to standard compaction.
+     "module align_off(\n"
+     "input w  ,\n"
+     "    // verilog_format: off\n"
+     "input wire  [y:z] wwww,\n"
+     "    // verilog_format: on\n"
+     "output  reg    xx\n"
+     ");\n"
+     "endmodule",
+     "module align_off (\n"
+     "    input w  ,\n"  // preserved because group is partially disabled
+     "    // verilog_format: off\n"
+     "input wire  [y:z] wwww,\n"  // not compacted
+     "    // verilog_format: on\n"
+     "    output  reg    xx\n"  // preserved because group is partially disabled
+     ");\n"
+     "endmodule\n"},
+
+    {// multiple tokens with EOL comment
+     "module please;  // don't break before the comment\n"
+     "endmodule\n",
+     "module please\n"
+     "    ;  // don't break before the comment\n"
+     "endmodule\n"},
+    {// one token with EOL comment
+     "module please;\n"
+     "endmodule  // don't break before the comment\n",
+     "module please;\n"
+     "endmodule  // don't break before the comment\n"},
+    {
+        // line with only an EOL comment
+        "module wild;\n"
+        "// a really long comment on its own line to be left alone\n"
+        "endmodule",
+        "module wild;\n"
+        "  // a really long comment on its own line to be left alone\n"
+        "endmodule\n",
+    },
+    {
+        // primitive declaration
+        "primitive primitive1(o, s, r);output o;reg o;input s;input r;table 1 "
+        "? :"
+        " ? : 0; ? 1    : 0   : -; endtable endprimitive",
+        "primitive primitive1(o, s, r);\n"
+        "  output o;\n"
+        "  reg o;\n"
+        "  input s;\n"
+        "  input r;\n"
+        "  table\n"
+        "    1 ? : ? : 0;\n"
+        "    ? 1 : 0 : -;\n"
+        "  endtable\n"
+        "endprimitive\n",
+    },
+    {
+        // one-input combinatorial UDP
+        "primitive primitive1 ( o,i ) ;output o;input i;"
+        " table 1  :   0 ;   0  :  1 ; endtable endprimitive",
+        "primitive primitive1(o, i);\n"
+        "  output o;\n"
+        "  input i;\n"
+        "  table\n"
+        "    1 : 0;\n"
+        "    0 : 1;\n"
+        "  endtable\n"
+        "endprimitive\n",
+    },
+    {
+        // two-input combinatorial UDP
+        "primitive primitive2(o, s, r);output o;input s;input r;"
+        "table 1 ? : 0;? 1 : -; endtable endprimitive",
+        "primitive primitive2(o, s, r);\n"
+        "  output o;\n"
+        "  input s;\n"
+        "  input r;\n"
+        "  table\n"
+        "    1 ? : 0;\n"
+        "    ? 1 : -;\n"
+        "  endtable\n"
+        "endprimitive\n",
+    },
+    {
+        // ten-input combinatorial UDP
+        "primitive comb10(o, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);"
+        "output o;input i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;"
+        "table 0 ? ? ? ? ? ? ? ? 0 : 0;1 ? ? ? ? ? ? ? ? 0 : 1;"
+        "1 ? ? ? ? ? ? ? ? 1 : 1;0 ? ? ? ? ? ? ? ? 1 : 0;endtable endprimitive",
+        "primitive comb10(o, i0, i1, i2, i3, i4,\n"
+        "                 i5, i6, i7, i8, i9);\n"
+        "  output o;\n"
+        "  input i0, i1, i2, i3, i4, i5, i6, i7,\n"
+        "      i8, i9;\n"
+        "  table\n"
+        "    0 ? ? ? ? ? ? ? ? 0 : 0;\n"
+        "    1 ? ? ? ? ? ? ? ? 0 : 1;\n"
+        "    1 ? ? ? ? ? ? ? ? 1 : 1;\n"
+        "    0 ? ? ? ? ? ? ? ? 1 : 0;\n"
+        "  endtable\n"
+        "endprimitive\n",
+    },
+    {
+        // sequential level-sensitive UDP
+        "primitive level_seq(o, c, d);output o;reg o;"
+        "  input c;input d;table\n"
+        "//  C D  state O\n"
+        "0   ? : ? :  -;  // No Change\n"
+        "? 0   : 0 :  0;  // Unknown\n"
+        "endtable endprimitive",
+        "primitive level_seq(o, c, d);\n"
+        "  output o;\n"
+        "  reg o;\n"
+        "  input c;\n"
+        "  input d;\n"
+        "  table\n"
+        "    //  C D  state O\n"
+        "    0 ? : ? : -;  // No Change\n"
+        "    ? 0 : 0 : 0;  // Unknown\n"
+        "  endtable\n"
+        "endprimitive\n",
+    },
+    {
+        // sequential edge-sensitive UDP
+        "primitive edge_seq(o, c, d);output o;reg o;input c;input d;"
+        "table (01) 0 : ? :  0;(01) 1 : ? :  1;(0?) 1 : 1 :  1;(0?) 0 : 0 :  "
+        "0;\n"
+        "// ignore negative c\n"
+        "(?0) ? : ? :  -;\n"
+        "// ignore changes on steady c\n"
+        "?  (?\?) : ? :  -; endtable endprimitive",
+        "primitive edge_seq(o, c, d);\n"
+        "  output o;\n"
+        "  reg o;\n"
+        "  input c;\n"
+        "  input d;\n"
+        "  table\n"
+        "    (01) 0 : ? : 0;\n"
+        "    (01) 1 : ? : 1;\n"
+        "    (0?) 1 : 1 : 1;\n"
+        "    (0?) 0 : 0 : 0;\n"
+        "    // ignore negative c\n"
+        "    (?0) ? : ? : -;\n"
+        "    // ignore changes on steady c\n"
+        "    ? (?\?) : ? : -;\n"
+        "  endtable\n"
+        "endprimitive\n",
+    },
+    {
+        // mixed sequential UDP
+        "primitive mixed(o, clk, j, k, preset, clear);output o;reg o;"
+        "input c;input j, k;input preset, clear;table "
+        "?  ??  01:?:1 ; // preset logic\n"
+        "?  ??  *1:1:1 ;?  ??  10:?:0 ; // clear logic\n"
+        "?  ??  1*:0:0 ;r  00  00:0:1 ; // normal\n"
+        "r  00  11:?:- ;r  01  11:?:0 ;r  10  11:?:1 ;r  11  11:0:1 ;"
+        "r  11  11:1:0 ;f  ??  ??:?:- ;b  *?  ??:?:- ;"
+        " // j and k\n"
+        "b  ?*  ??:?:- ;endtable endprimitive\n",
+        "primitive mixed(o, clk, j, k, preset,\n"
+        "                clear);\n"
+        "  output o;\n"
+        "  reg o;\n"
+        "  input c;\n"
+        "  input j, k;\n"
+        "  input preset, clear;\n"
+        "  table\n"
+        "    ? ? ? 0 1 : ? : 1;  // preset logic\n"
+        "    ? ? ? * 1 : 1 : 1;\n"
+        "    ? ? ? 1 0 : ? : 0;  // clear logic\n"
+        "    ? ? ? 1 * : 0 : 0;\n"
+        "    r 0 0 0 0 : 0 : 1;  // normal\n"
+        "    r 0 0 1 1 : ? : -;\n"
+        "    r 0 1 1 1 : ? : 0;\n"
+        "    r 1 0 1 1 : ? : 1;\n"
+        "    r 1 1 1 1 : 0 : 1;\n"
+        "    r 1 1 1 1 : 1 : 0;\n"
+        "    f ? ? ? ? : ? : -;\n"
+        "    b * ? ? ? : ? : -;  // j and k\n"
+        "    b ? * ? ? : ? : -;\n"
+        "  endtable\n"
+        "endprimitive\n",
+    },
+    // un-lexed multiline macro arg token
+    {
+        " task  S ; "
+        "`ppgJH3JoxhwyTmZ2dgPiuMQzpRAWiSs("
+        "{xYtxuh6.FIMcVPEWfhtoI2FSe, xYtxuh6.ZVL5XASVGLYz32} == "
+        "SqRgavM[15:2];\n"
+        "JgQLBG == 4'h0;, \"foo\" )\n"
+        "endtask\n",
+        "task S;\n"
+        "  `ppgJH3JoxhwyTmZ2dgPiuMQzpRAWiSs(\n"
+        "      {xYtxuh6.FIMcVPEWfhtoI2FSe, xYtxuh6.ZVL5XASVGLYz32} == "
+        "SqRgavM[15:2];\n"
+        "JgQLBG == 4'h0;,\n"
+        "      \"foo\")\n"
+        "endtask\n",
+    },
+
+    // between identifier and '(', no args
+
+    {"// verilog_syntax: parse-as-module-body",
+     "// verilog_syntax: parse-as-module-body\n"},
+    {"// verilog_syntax: parse-as-statements",
+     "// verilog_syntax: parse-as-statements\n"},
+    {"// verilog_syntax: parse-as-class-body",
+     "// verilog_syntax: parse-as-class-body\n"},
+    {"// verilog_syntax: parse-as-package-body",
+     "// verilog_syntax: parse-as-package-body\n"},
+    {"// verilog_syntax: parse-as-library-map",
+     "// verilog_syntax: parse-as-library-map\n"},
+    {"// verilog_syntax: does-not-exist-mode",
+     "// verilog_syntax: does-not-exist-mode\n"},
+    {"// verilog_syntax: parse-as-module-body\n",
+     "// verilog_syntax: parse-as-module-body\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "// comment",
+     "// verilog_syntax: parse-as-module-body\n"
+     "// comment\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c */ ();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c */ ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */ /* c2 */ ();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  /* c2 */ ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c */\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c */\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */ /* c2 */\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  /* c2 */\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz // c\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */ // c2\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  // c2\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c */ ();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c */ ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ /* c2 */ ();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  /* c2 */ ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c */\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c */\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ /* c2 */\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  /* c2 */\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "// c\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    // c\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ // c2\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  // c2\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "// c1\n"
+     "// c2\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    // c1\n"
+     "    // c2\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */\n"
+     "/* c2 */ ();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */ ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz // c1\n"
+     "/* c2 */ ();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    /* c2 */ ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */ ();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */ ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */\n"
+     "/* c2 */\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz // c1\n"
+     "/* c2 */\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    /* c2 */\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */\n"
+     "// c2\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    // c2\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz // c1\n"
+     "// c2\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    // c2\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     "    ();\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz // c1\n"
+     "// c2\n"
+     "// c3\n"
+     "();\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     "    ();\n"},
+
+    // between identifier and '(', with arg
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c */ (arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c */ (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */ /* c2 */ (arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  /* c2 */ (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c */\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c */\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */ /* c2 */\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  /* c2 */\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz // c\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */ // c2\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  // c2\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c */ (arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c */ (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ /* c2 */ (arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  /* c2 */ (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c */\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c */\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ /* c2 */\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  /* c2 */\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "// c\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    // c\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ // c2\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  // c2\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "// c1\n"
+     "// c2\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    // c1\n"
+     "    // c2\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */\n"
+     "/* c2 */ (arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */ (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz // c1\n"
+     "/* c2 */ (arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    /* c2 */ (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */ (arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */ (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */\n"
+     "/* c2 */\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz // c1\n"
+     "/* c2 */\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    /* c2 */\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */\n"
+     "// c2\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    // c2\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz // c1\n"
+     "// c2\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    // c2\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     "    (arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz // c1\n"
+     "// c2\n"
+     "// c3\n"
+     "(arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     "    (arg);\n"},
+
+    // after '(', no args
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    // c1\n"
+     "    // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(// c1\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  // c1\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */\n"
+     "    /* c2 */\n"
+     "/* c3 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */\n"
+     "    /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(// c1\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  // c1\n"
+     "    /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */\n"
+     "    // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  // c1\n"
+     "    // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    // c1\n"
+     "    // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     "/* c3 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     ");\n"},
+
+    // after '(', with arg
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */ /* c2 */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */  /* c2 */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */ /* c2 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */  /* c2 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(// c\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  // c\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */ // c2\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */  // c2\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    /* c */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c1 */ /* c2 */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    /* c1 */  /* c2 */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    /* c */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c1 */ /* c2 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    /* c1 */  /* c2 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "// c\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    // c\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c1 */ // c2\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    /* c1 */  // c2\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "// c1\n"
+     "// c2\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(\n"
+     "    // c1\n"
+     "    // c2\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */\n"
+     "/* c2 */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */\n"
+     "    /* c2 */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(// c1\n"
+     "/* c2 */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  // c1\n"
+     "    /* c2 */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */\n"
+     "/* c2 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(// c1\n"
+     "/* c2 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  // c1\n"
+     "    /* c2 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */\n"
+     "// c2\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */\n"
+     "    // c2\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(// c1\n"
+     "// c2\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  // c1\n"
+     "    // c2\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(// c1\n"
+     "// c2\n"
+     "// c3\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ /* c2 */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  /* c2 */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ /* c2 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  /* c2 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ // c2\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  // c2\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ /* c2 */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */  /* c2 */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ /* c2 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */  /* c2 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "// c\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    // c\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ // c2\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */  // c2\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "// c1\n"
+     "// c2\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    // c1\n"
+     "    // c2\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "/* c2 */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    /* c2 */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */ arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "/* c2 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    /* c2 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "// c2\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    // c2\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "// c2\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    // c2\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     "    arg);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "// c2\n"
+     "// c3\n"
+     "arg);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     "    arg);\n"},
+
+    // after single arg
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  /* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  /* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "/* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "/* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "           /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "           /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "           // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "           /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "           /* c1 */\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg\n"
+     "           // c1\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg/* c1 */\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  /* c1 */\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg// c1\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  // c1\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  /* c1 */\n"
+     "           /* c2 */\n"
+     "/* c3 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  /* c1 */\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg// c1\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  // c1\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg/* c1 */\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  /* c1 */\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  // c1\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg  // c1\n"
+     "           // c2\n"
+     "           // c3\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  /* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  /* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "/* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "/* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "           /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "           /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "           // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "           /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "           /* c1 */\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg\n"
+     "           // c1\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg/* c1 */\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  /* c1 */\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg// c1\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  // c1\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  /* c1 */\n"
+     "           /* c2 */\n"
+     "/* c3 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  /* c1 */\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg// c1\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  // c1\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg/* c1 */\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  /* c1 */\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  // c1\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg  // c1\n"
+     "           // c2\n"
+     "           // c3\n"
+     ");\n"},
+
+    // before colon
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1/* c */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  /* c */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1/* c1 */ /* c2 */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  /* c1 */  /* c2 */,\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1/* c */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  /* c */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1/* c1 */ /* c2 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  /* c1 */  /* c2 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1// c\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  // c\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1/* c1 */ // c2\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  /* c1 */  // c2\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "/* c */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "           /* c */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "/* c1 */ /* c2 */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "           /* c1 */  /* c2 */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "/* c */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "           /* c */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "/* c1 */ /* c2 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "           /* c1 */  /* c2 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "// c\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "           // c\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "/* c1 */ // c2\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "           /* c1 */  // c2\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "           /* c1 */\n"
+     "           /* c2 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "// c1\n"
+     "// c2\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1\n"
+     "           // c1\n"
+     "           // c2\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1/* c1 */\n"
+     "/* c2 */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  /* c1 */\n"
+     "           /* c2 */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1// c1\n"
+     "/* c2 */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  // c1\n"
+     "           /* c2 */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1/* c1 */\n"
+     "/* c2 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  /* c1 */\n"
+     "           /* c2 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1// c1\n"
+     "/* c2 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  // c1\n"
+     "           /* c2 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1/* c1 */\n"
+     "// c2\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  /* c1 */\n"
+     "           // c2\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1// c1\n"
+     "// c2\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  // c1\n"
+     "           // c2\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1  // c1\n"
+     "           // c2\n"
+     "           // c3\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1/* c */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  /* c */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1/* c1 */ /* c2 */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  /* c1 */  /* c2 */,\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1/* c */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  /* c */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1/* c1 */ /* c2 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  /* c1 */  /* c2 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1// c\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  // c\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1/* c1 */ // c2\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  /* c1 */  // c2\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "/* c */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "           /* c */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "/* c1 */ /* c2 */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "           /* c1 */  /* c2 */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "/* c */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "           /* c */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "/* c1 */ /* c2 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "           /* c1 */  /* c2 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "// c\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "           // c\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "/* c1 */ // c2\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "           /* c1 */  // c2\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "           /* c1 */\n"
+     "           /* c2 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "// c1\n"
+     "// c2\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1\n"
+     "           // c1\n"
+     "           // c2\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1/* c1 */\n"
+     "/* c2 */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  /* c1 */\n"
+     "           /* c2 */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1// c1\n"
+     "/* c2 */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  // c1\n"
+     "           /* c2 */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */, arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */, arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1/* c1 */\n"
+     "/* c2 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  /* c1 */\n"
+     "           /* c2 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1// c1\n"
+     "/* c2 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  // c1\n"
+     "           /* c2 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1/* c1 */\n"
+     "// c2\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  /* c1 */\n"
+     "           // c2\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1// c1\n"
+     "// c2\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  // c1\n"
+     "           // c2\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */\n"
+     "           , arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ", arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1  // c1\n"
+     "           // c2\n"
+     "           // c3\n"
+     "           , arg2);\n"},
+
+    // after colon
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,/* c */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  /* c */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,/* c1 */ /* c2 */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  /* c1 */  /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,/* c */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  /* c */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,/* c1 */ /* c2 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  /* c1 */  /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,// c\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  // c\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,/* c1 */ // c2\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  /* c1 */  // c2\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "/* c */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "           /* c */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "/* c1 */ /* c2 */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "           /* c1 */  /* c2 */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "/* c */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "           /* c */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "/* c1 */ /* c2 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "           /* c1 */  /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "// c\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "           // c\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "/* c1 */ // c2\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "           /* c1 */  // c2\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "           /* c1 */\n"
+     "           /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "// c1\n"
+     "// c2\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "           // c1\n"
+     "           // c2\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,/* c1 */\n"
+     "/* c2 */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  /* c1 */\n"
+     "           /* c2 */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,// c1\n"
+     "/* c2 */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  // c1\n"
+     "           /* c2 */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,/* c1 */\n"
+     "/* c2 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  /* c1 */\n"
+     "           /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,// c1\n"
+     "/* c2 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  // c1\n"
+     "           /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,/* c1 */\n"
+     "// c2\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  /* c1 */\n"
+     "           // c2\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,// c1\n"
+     "// c2\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  // c1\n"
+     "           // c2\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,// c1\n"
+     "// c2\n"
+     "// c3\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,  // c1\n"
+     "           // c2\n"
+     "           // c3\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,/* c */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  /* c */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,/* c1 */ /* c2 */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  /* c1 */  /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,/* c */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  /* c */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,/* c1 */ /* c2 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  /* c1 */  /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,// c\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  // c\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,/* c1 */ // c2\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  /* c1 */  // c2\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "/* c */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "           /* c */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "/* c1 */ /* c2 */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "           /* c1 */  /* c2 */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "/* c */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "           /* c */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "/* c1 */ /* c2 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "           /* c1 */  /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "// c\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "           // c\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "/* c1 */ // c2\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "           /* c1 */  // c2\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "           /* c1 */\n"
+     "           /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "// c1\n"
+     "// c2\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "           // c1\n"
+     "           // c2\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,/* c1 */\n"
+     "/* c2 */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  /* c1 */\n"
+     "           /* c2 */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,// c1\n"
+     "/* c2 */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  // c1\n"
+     "           /* c2 */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */ arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,/* c1 */\n"
+     "/* c2 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  /* c1 */\n"
+     "           /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,// c1\n"
+     "/* c2 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  // c1\n"
+     "           /* c2 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,/* c1 */\n"
+     "// c2\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  /* c1 */\n"
+     "           // c2\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,// c1\n"
+     "// c2\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  // c1\n"
+     "           // c2\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */\n"
+     "           arg2);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,// c1\n"
+     "// c2\n"
+     "// c3\n"
+     "arg2);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,  // c1\n"
+     "           // c2\n"
+     "           // c3\n"
+     "           arg2);\n"},
+
+    // after last arg
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  /* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "           arg2,  /* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1,\n"
+     "           arg2,  /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "/* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "/* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "           /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "           /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "           // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "           /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "           /* c1 */\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,\n"
+     "           // c1\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,/* c1 */\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  /* c1 */\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,// c1\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  // c1\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  /* c1 */\n"
+     "           /* c2 */\n"
+     "/* c3 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  /* c1 */\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,// c1\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  // c1\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,/* c1 */\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  /* c1 */\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  // c1\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg1, arg2,  // c1\n"
+     "           // c2\n"
+     "           // c3\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  /* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "           arg2,  /* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1,\n"
+     "           arg2,  /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "/* c */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "/* c */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "/* c1 */ /* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "/* c1 */  /* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "/* c */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "           /* c */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "/* c1 */ /* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "           /* c1 */  /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "// c\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "           // c\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "/* c1 */ // c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "           /* c1 */  // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "           /* c1 */\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,\n"
+     "           // c1\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,/* c1 */\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  /* c1 */\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,// c1\n"
+     "/* c2 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  // c1\n"
+     "/* c2 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */);\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  /* c1 */\n"
+     "           /* c2 */\n"
+     "/* c3 */);\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,/* c1 */\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  /* c1 */\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,// c1\n"
+     "/* c2 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  // c1\n"
+     "           /* c2 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,/* c1 */\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  /* c1 */\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,// c1\n"
+     "// c2\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  // c1\n"
+     "           // c2\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  /* c1 */\n"
+     "           /* c2 */\n"
+     "           /* c3 */\n"
+     ");\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ");\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg1, arg2,  // c1\n"
+     "           // c2\n"
+     "           // c3\n"
+     ");\n"},
+
+    // after ')', no args
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()/* c */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  /* c */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()/* c1 */ /* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  /* c1 */  /* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()/* c */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  /* c */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()/* c1 */ /* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  /* c1 */  /* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()// c\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  // c\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()/* c1 */ // c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  /* c1 */  // c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c1 */ /* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c1 */  /* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c1 */ /* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c1 */  /* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "// c\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "// c\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c1 */ // c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c1 */  // c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()/* c1 */\n"
+     "/* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  /* c1 */\n"
+     "/* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()// c1\n"
+     "/* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  // c1\n"
+     "/* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()/* c1 */\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  /* c1 */\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()// c1\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  // c1\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()/* c1 */\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  /* c1 */\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()// c1\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  // c1\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz()  // c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()/* c */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  /* c */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()/* c1 */ /* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  /* c1 */  /* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()/* c */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  /* c */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()/* c1 */ /* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  /* c1 */  /* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()// c\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  // c\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()/* c1 */ // c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  /* c1 */  // c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c1 */ /* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c1 */  /* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c1 */ /* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c1 */  /* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "// c\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "// c\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c1 */ // c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c1 */  // c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()/* c1 */\n"
+     "/* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  /* c1 */\n"
+     "/* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()// c1\n"
+     "/* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  // c1\n"
+     "/* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()/* c1 */\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  /* c1 */\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()// c1\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  // c1\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()/* c1 */\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  /* c1 */\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()// c1\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  // c1\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ()  // c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";\n"},
+
+    // after ')', with arg
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)/* c */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  /* c */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)/* c1 */ /* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  /* c1 */  /* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)/* c */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  /* c */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)/* c1 */ /* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  /* c1 */  /* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)// c\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  // c\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)/* c1 */ // c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  /* c1 */  // c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c1 */ /* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c1 */  /* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c1 */ /* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c1 */  /* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "// c\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  // c\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c1 */ // c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c1 */  // c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)/* c1 */\n"
+     "/* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  /* c1 */\n"
+     "/* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)// c1\n"
+     "/* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  // c1\n"
+     "/* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)/* c1 */\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  /* c1 */\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)// c1\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  // c1\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)/* c1 */\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  /* c1 */\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)// c1\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  // c1\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg)  // c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)/* c */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  /* c */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)/* c1 */ /* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  /* c1 */  /* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)/* c */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  /* c */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)/* c1 */ /* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  /* c1 */  /* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)// c\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  // c\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)/* c1 */ // c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  /* c1 */  // c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c1 */ /* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c1 */  /* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c1 */ /* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c1 */  /* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "// c\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "// c\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c1 */ // c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c1 */  // c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)/* c1 */\n"
+     "/* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  /* c1 */\n"
+     "/* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)// c1\n"
+     "/* c2 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  // c1\n"
+     "/* c2 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)/* c1 */\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  /* c1 */\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)// c1\n"
+     "/* c2 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  // c1\n"
+     "/* c2 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)/* c1 */\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  /* c1 */\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)// c1\n"
+     "// c2\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  // c1\n"
+     "// c2\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg)  // c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";\n"},
+
+    // after ';', no args
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  // c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  /* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "// c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "/* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();\n"
+     "// c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();// c1 c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  // c1 c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();/* c1 */\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  /* c1 */\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  // c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();// c1\n"
+     "// c2\n"
+     "// c3\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz();  // c1\n"
+     "// c2\n"
+     "// c3\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  // c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  /* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "// c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "/* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();\n"
+     "// c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();/* c1 */\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  /* c1 */\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  // c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();// c1\n"
+     "// c2\n"
+     "// c3\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ();  // c1\n"
+     "// c2\n"
+     "// c3\n"},
+
+    // after ';', with arg
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  // c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  /* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "// c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "/* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);\n"
+     "// c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);// c1 c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  // c1 c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);/* c1 */\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  /* c1 */\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  // c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);// c1\n"
+     "// c2\n"
+     "// c3\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz(arg);  // c1\n"
+     "// c2\n"
+     "// c3\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  // c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  /* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "// c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "/* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);\n"
+     "// c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);/* c1 */\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  /* c1 */\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  // c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);// c1\n"
+     "// c2\n"
+     "// c3\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(arg);  // c1\n"
+     "// c2\n"
+     "// c3\n"},
+
+    // everywhere, no args
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c */(/* c */)/* c */;/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c */\n"
+     "    (  /* c */)  /* c */;  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */ /* c2 */(/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ "
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  /* c2 */\n"
+     "    (  /* c1 */  /* c2 */)  /* c1 */  /* c2 */;  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c */\n"
+     "(/* c */\n"
+     ")/* c */\n"
+     ";/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c */\n"
+     "    (  /* c */\n"
+     "    )  /* c */\n"
+     ";  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */ /* c2 */\n"
+     "(/* c1 */ /* c2 */\n"
+     ")/* c1 */ /* c2 */\n"
+     ";/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  /* c2 */\n"
+     "    (  /* c1 */  /* c2 */\n"
+     "    )  /* c1 */  /* c2 */\n"
+     ";  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz// c\n"
+     "(// c\n"
+     ")// c\n"
+     ";// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c\n"
+     "    (  // c\n"
+     "    )  // c\n"
+     ";  // c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */ // c2\n"
+     "(/* c1 */ // c2\n"
+     ")/* c1 */ // c2\n"
+     ";/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  // c2\n"
+     "    (  /* c1 */  // c2\n"
+     "    )  /* c1 */  // c2\n"
+     ";  /* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c */(\n"
+     "/* c */)\n"
+     "/* c */;\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c */ (\n"
+     "    /* c */)\n"
+     "/* c */;\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ /* c2 */(\n"
+     "/* c1 */ /* c2 */)\n"
+     "/* c1 */ /* c2 */;\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  /* c2 */ (\n"
+     "    /* c1 */  /* c2 */)\n"
+     "/* c1 */  /* c2 */;\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c */\n"
+     "(\n"
+     "/* c */\n"
+     ")\n"
+     "/* c */\n"
+     ";\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c */\n"
+     "    (\n"
+     "        /* c */\n"
+     "    )\n"
+     "/* c */\n"
+     ";\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ /* c2 */\n"
+     "(\n"
+     "/* c1 */ /* c2 */\n"
+     ")\n"
+     "/* c1 */ /* c2 */\n"
+     ";\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  /* c2 */\n"
+     "    (\n"
+     "        /* c1 */  /* c2 */\n"
+     "    )\n"
+     "/* c1 */  /* c2 */\n"
+     ";\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "// c\n"
+     "(\n"
+     "// c\n"
+     ")\n"
+     "// c\n"
+     ";\n"
+     "// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    // c\n"
+     "    (\n"
+     "        // c\n"
+     "    )\n"
+     "// c\n"
+     ";\n"
+     "// c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ // c2\n"
+     "(\n"
+     "/* c1 */ // c2\n"
+     ")\n"
+     "/* c1 */ // c2\n"
+     ";\n"
+     "/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  // c2\n"
+     "    (\n"
+     "        /* c1 */  // c2\n"
+     "    )\n"
+     "/* c1 */  // c2\n"
+     ";\n"
+     "/* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "(\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ")\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"
+     "/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     "    (\n"
+     "        /* c1 */\n"
+     "        /* c2 */\n"
+     "    )\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"
+     "/* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "// c1\n"
+     "// c2\n"
+     "(\n"
+     "// c1\n"
+     "// c2\n"
+     ")\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"
+     "// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    // c1\n"
+     "    // c2\n"
+     "    (\n"
+     "        // c1\n"
+     "        // c2\n"
+     "    )\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"
+     "// c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */\n"
+     "/* c2 */(/* c1 */\n"
+     "/* c2 */)/* c1 */\n"
+     "/* c2 */;/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */ (  /* c1 */\n"
+     "    /* c2 */)  /* c1 */\n"
+     "/* c2 */;  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz// c1\n"
+     "/* c2 */(// c1\n"
+     "/* c2 */)// c1\n"
+     "/* c2 */;// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    /* c2 */ (  // c1\n"
+     "    /* c2 */)  // c1\n"
+     "/* c2 */;  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */)/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */ (  /* c1 */\n"
+     "        /* c2 */\n"
+     "    /* c3 */)  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */\n"
+     "/* c2 */\n"
+     "(/* c1 */\n"
+     "/* c2 */\n"
+     ")/* c1 */\n"
+     "/* c2 */\n"
+     ";/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    (  /* c1 */\n"
+     "        /* c2 */\n"
+     "    )  /* c1 */\n"
+     "/* c2 */\n"
+     ";  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz// c1\n"
+     "/* c2 */\n"
+     "(// c1\n"
+     "/* c2 */\n"
+     ")// c1\n"
+     "/* c2 */\n"
+     ";// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    /* c2 */\n"
+     "    (  // c1\n"
+     "        /* c2 */\n"
+     "    )  // c1\n"
+     "/* c2 */\n"
+     ";  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */\n"
+     "// c2\n"
+     "(/* c1 */\n"
+     "// c2\n"
+     ")/* c1 */\n"
+     "// c2\n"
+     ";/* c1 */\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    // c2\n"
+     "    (  /* c1 */\n"
+     "        // c2\n"
+     "    )  /* c1 */\n"
+     "// c2\n"
+     ";  /* c1 */\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz// c1\n"
+     "// c2\n"
+     "(// c1\n"
+     "// c2\n"
+     ")// c1\n"
+     "// c2\n"
+     ";// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    // c2\n"
+     "    (  // c1\n"
+     "       // c2\n"
+     "    )  // c1\n"
+     "       // c2\n"
+     ";  // c1\n"
+     "   // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ")/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     "    (  /* c1 */\n"
+     "        /* c2 */\n"
+     "        /* c3 */\n"
+     "    )  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz// c1\n"
+     "// c2\n"
+     "// c3\n"
+     "(// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ")// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";// c1\n"
+     "// c2\n"
+     "// c3\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     "    (  // c1\n"
+     "       // c2\n"
+     "       // c3\n"
+     "    )  // c1\n"
+     "       // c2\n"
+     "       // c3\n"
+     ";  // c1\n"
+     "   // c2\n"
+     "   // c3\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c */)/* c */;/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c */)  /* c */;  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  /* c2 */)  /* c1 */  /* c2 */;  /* c1 */  /* c2 "
+     "*/\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c */\n"
+     ")/* c */\n"
+     ";/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c */\n"
+     ")  /* c */\n"
+     ";  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ /* c2 */\n"
+     ")/* c1 */ /* c2 */\n"
+     ";/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  /* c2 */\n"
+     ")  /* c1 */  /* c2 */\n"
+     ";  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c\n"
+     ")// c\n"
+     ";// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c\n"
+     ")  // c\n"
+     ";  // c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ // c2\n"
+     ")/* c1 */ // c2\n"
+     ";/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  // c2\n"
+     ")  /* c1 */  // c2\n"
+     ";  /* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c */)\n"
+     "/* c */;\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c */)\n"
+     "/* c */;\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ /* c2 */)\n"
+     "/* c1 */ /* c2 */;\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */  /* c2 */)\n"
+     "/* c1 */  /* c2 */;\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c */\n"
+     ")\n"
+     "/* c */\n"
+     ";\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c */\n"
+     ")\n"
+     "/* c */\n"
+     ";\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ /* c2 */\n"
+     ")\n"
+     "/* c1 */ /* c2 */\n"
+     ";\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */  /* c2 */\n"
+     ")\n"
+     "/* c1 */  /* c2 */\n"
+     ";\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "// c\n"
+     ")\n"
+     "// c\n"
+     ";\n"
+     "// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    // c\n"
+     ")\n"
+     "// c\n"
+     ";\n"
+     "// c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ // c2\n"
+     ")\n"
+     "/* c1 */ // c2\n"
+     ";\n"
+     "/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */  // c2\n"
+     ")\n"
+     "/* c1 */  // c2\n"
+     ";\n"
+     "/* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ")\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"
+     "/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     ")\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"
+     "/* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "// c1\n"
+     "// c2\n"
+     ")\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"
+     "// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    // c1\n"
+     "    // c2\n"
+     ")\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"
+     "// c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */)/* c1 */\n"
+     "/* c2 */;/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "/* c2 */)  /* c1 */\n"
+     "/* c2 */;  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "/* c2 */)// c1\n"
+     "/* c2 */;// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "/* c2 */)  // c1\n"
+     "/* c2 */;  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */)/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     "/* c3 */)  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     ")/* c1 */\n"
+     "/* c2 */\n"
+     ";/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     ")  /* c1 */\n"
+     "/* c2 */\n"
+     ";  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "/* c2 */\n"
+     ")// c1\n"
+     "/* c2 */\n"
+     ";// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    /* c2 */\n"
+     ")  // c1\n"
+     "/* c2 */\n"
+     ";  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "// c2\n"
+     ")/* c1 */\n"
+     "// c2\n"
+     ";/* c1 */\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    // c2\n"
+     ")  /* c1 */\n"
+     "// c2\n"
+     ";  /* c1 */\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "// c2\n"
+     ")// c1\n"
+     "// c2\n"
+     ";// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    // c2\n"
+     ")  // c1\n"
+     "   // c2\n"
+     ";  // c1\n"
+     "   // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ")/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     ")  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ")// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";// c1\n"
+     "// c2\n"
+     "// c3\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     ")  // c1\n"
+     "   // c2\n"
+     "   // c3\n"
+     ";  // c1\n"
+     "   // c2\n"
+     "   // c3\n"},
+
+    // everywhere, with args
+
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c */(/* c */arg1/* c */,/* c */arg2/* c */)/* c */;/* c "
+     "*/\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c */ (  /* c */\n"
+     "    arg1  /* c */,  /* c */\n"
+     "    arg2  /* c */)  /* c */;  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */ /* c2 */(/* c1 */ /* c2 */arg1/* c1 */ /* c2 */,/* c1 "
+     "*/ /* c2 */arg2/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  /* c2 */ (  /* c1 */  /* c2 */\n"
+     "    arg1  /* c1 */  /* c2 */,  /* c1 */  /* c2 */\n"
+     "    arg2  /* c1 */  /* c2 */)  /* c1 */  /* c2 */;  /* c1 */  /* c2 "
+     "*/\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c */\n"
+     "(/* c */\n"
+     "arg1/* c */\n"
+     ",/* c */\n"
+     "arg2/* c */\n"
+     ")/* c */\n"
+     ";/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c */\n"
+     "    (  /* c */\n"
+     "        arg1  /* c */\n"
+     "        ,  /* c */\n"
+     "        arg2  /* c */\n"
+     "    )  /* c */\n"
+     ";  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */ /* c2 */\n"
+     "(/* c1 */ /* c2 */\n"
+     "arg1/* c1 */ /* c2 */\n"
+     ",/* c1 */ /* c2 */\n"
+     "arg2/* c1 */ /* c2 */\n"
+     ")/* c1 */ /* c2 */\n"
+     ";/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  /* c2 */\n"
+     "    (  /* c1 */  /* c2 */\n"
+     "        arg1  /* c1 */  /* c2 */\n"
+     "        ,  /* c1 */  /* c2 */\n"
+     "        arg2  /* c1 */  /* c2 */\n"
+     "    )  /* c1 */  /* c2 */\n"
+     ";  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz// c\n"
+     "(// c\n"
+     "arg1// c\n"
+     ",// c\n"
+     "arg2// c\n"
+     ")// c\n"
+     ";// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c\n"
+     "    (  // c\n"
+     "        arg1  // c\n"
+     "        ,  // c\n"
+     "        arg2  // c\n"
+     "    )  // c\n"
+     ";  // c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */ // c2\n"
+     "(/* c1 */ // c2\n"
+     "arg1/* c1 */ // c2\n"
+     ",/* c1 */ // c2\n"
+     "arg2/* c1 */ // c2\n"
+     ")/* c1 */ // c2\n"
+     ";/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */  // c2\n"
+     "    (  /* c1 */  // c2\n"
+     "        arg1  /* c1 */  // c2\n"
+     "        ,  /* c1 */  // c2\n"
+     "        arg2  /* c1 */  // c2\n"
+     "    )  /* c1 */  // c2\n"
+     ";  /* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c */(\n"
+     "/* c */arg1\n"
+     "/* c */,\n"
+     "/* c */arg2\n"
+     "/* c */)\n"
+     "/* c */;\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c */ (\n"
+     "        /* c */ arg1\n"
+     "        /* c */,\n"
+     "        /* c */ arg2\n"
+     "    /* c */)\n"
+     "/* c */;\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ /* c2 */(\n"
+     "/* c1 */ /* c2 */arg1\n"
+     "/* c1 */ /* c2 */,\n"
+     "/* c1 */ /* c2 */arg2\n"
+     "/* c1 */ /* c2 */)\n"
+     "/* c1 */ /* c2 */;\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  /* c2 */ (\n"
+     "        /* c1 */  /* c2 */ arg1\n"
+     "        /* c1 */  /* c2 */,\n"
+     "        /* c1 */  /* c2 */ arg2\n"
+     "    /* c1 */  /* c2 */)\n"
+     "/* c1 */  /* c2 */;\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c */\n"
+     "(\n"
+     "/* c */\n"
+     "arg1\n"
+     "/* c */\n"
+     ",\n"
+     "/* c */\n"
+     "arg2\n"
+     "/* c */\n"
+     ")\n"
+     "/* c */\n"
+     ";\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c */\n"
+     "    (\n"
+     "        /* c */\n"
+     "        arg1\n"
+     "        /* c */\n"
+     "        ,\n"
+     "        /* c */\n"
+     "        arg2\n"
+     "        /* c */\n"
+     "    )\n"
+     "/* c */\n"
+     ";\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ /* c2 */\n"
+     "(\n"
+     "/* c1 */ /* c2 */\n"
+     "arg1\n"
+     "/* c1 */ /* c2 */\n"
+     ",\n"
+     "/* c1 */ /* c2 */\n"
+     "arg2\n"
+     "/* c1 */ /* c2 */\n"
+     ")\n"
+     "/* c1 */ /* c2 */\n"
+     ";\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  /* c2 */\n"
+     "    (\n"
+     "        /* c1 */  /* c2 */\n"
+     "        arg1\n"
+     "        /* c1 */  /* c2 */\n"
+     "        ,\n"
+     "        /* c1 */  /* c2 */\n"
+     "        arg2\n"
+     "        /* c1 */  /* c2 */\n"
+     "    )\n"
+     "/* c1 */  /* c2 */\n"
+     ";\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "// c\n"
+     "(\n"
+     "// c\n"
+     "arg1\n"
+     "// c\n"
+     ",\n"
+     "// c\n"
+     "arg2\n"
+     "// c\n"
+     ")\n"
+     "// c\n"
+     ";\n"
+     "// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    // c\n"
+     "    (\n"
+     "        // c\n"
+     "        arg1\n"
+     "        // c\n"
+     "        ,\n"
+     "        // c\n"
+     "        arg2\n"
+     "        // c\n"
+     "    )\n"
+     "// c\n"
+     ";\n"
+     "// c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */ // c2\n"
+     "(\n"
+     "/* c1 */ // c2\n"
+     "arg1\n"
+     "/* c1 */ // c2\n"
+     ",\n"
+     "/* c1 */ // c2\n"
+     "arg2\n"
+     "/* c1 */ // c2\n"
+     ")\n"
+     "/* c1 */ // c2\n"
+     ";\n"
+     "/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */  // c2\n"
+     "    (\n"
+     "        /* c1 */  // c2\n"
+     "        arg1\n"
+     "        /* c1 */  // c2\n"
+     "        ,\n"
+     "        /* c1 */  // c2\n"
+     "        arg2\n"
+     "        /* c1 */  // c2\n"
+     "    )\n"
+     "/* c1 */  // c2\n"
+     ";\n"
+     "/* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "(\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "arg1\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ",\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "arg2\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ")\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"
+     "/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     "    (\n"
+     "        /* c1 */\n"
+     "        /* c2 */\n"
+     "        arg1\n"
+     "        /* c1 */\n"
+     "        /* c2 */\n"
+     "        ,\n"
+     "        /* c1 */\n"
+     "        /* c2 */\n"
+     "        arg2\n"
+     "        /* c1 */\n"
+     "        /* c2 */\n"
+     "    )\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"
+     "/* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "// c1\n"
+     "// c2\n"
+     "(\n"
+     "// c1\n"
+     "// c2\n"
+     "arg1\n"
+     "// c1\n"
+     "// c2\n"
+     ",\n"
+     "// c1\n"
+     "// c2\n"
+     "arg2\n"
+     "// c1\n"
+     "// c2\n"
+     ")\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"
+     "// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz\n"
+     "    // c1\n"
+     "    // c2\n"
+     "    (\n"
+     "        // c1\n"
+     "        // c2\n"
+     "        arg1\n"
+     "        // c1\n"
+     "        // c2\n"
+     "        ,\n"
+     "        // c1\n"
+     "        // c2\n"
+     "        arg2\n"
+     "        // c1\n"
+     "        // c2\n"
+     "    )\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"
+     "// c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */\n"
+     "/* c2 */(/* c1 */\n"
+     "/* c2 */arg1/* c1 */\n"
+     "/* c2 */,/* c1 */\n"
+     "/* c2 */arg2/* c1 */\n"
+     "/* c2 */)/* c1 */\n"
+     "/* c2 */;/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */ (  /* c1 */\n"
+     "        /* c2 */ arg1  /* c1 */\n"
+     "        /* c2 */,  /* c1 */\n"
+     "        /* c2 */ arg2  /* c1 */\n"
+     "    /* c2 */)  /* c1 */\n"
+     "/* c2 */;  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz// c1\n"
+     "/* c2 */(// c1\n"
+     "/* c2 */arg1// c1\n"
+     "/* c2 */,// c1\n"
+     "/* c2 */arg2// c1\n"
+     "/* c2 */)// c1\n"
+     "/* c2 */;// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    /* c2 */ (  // c1\n"
+     "        /* c2 */ arg1  // c1\n"
+     "        /* c2 */,  // c1\n"
+     "        /* c2 */ arg2  // c1\n"
+     "    /* c2 */)  // c1\n"
+     "/* c2 */;  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */arg1/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */,/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */arg2/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */)/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */ (  /* c1 */\n"
+     "        /* c2 */\n"
+     "        /* c3 */ arg1  /* c1 */\n"
+     "        /* c2 */\n"
+     "        /* c3 */,  /* c1 */\n"
+     "        /* c2 */\n"
+     "        /* c3 */ arg2  /* c1 */\n"
+     "        /* c2 */\n"
+     "    /* c3 */)  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */\n"
+     "/* c2 */\n"
+     "(/* c1 */\n"
+     "/* c2 */\n"
+     "arg1/* c1 */\n"
+     "/* c2 */\n"
+     ",/* c1 */\n"
+     "/* c2 */\n"
+     "arg2/* c1 */\n"
+     "/* c2 */\n"
+     ")/* c1 */\n"
+     "/* c2 */\n"
+     ";/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    (  /* c1 */\n"
+     "        /* c2 */\n"
+     "        arg1  /* c1 */\n"
+     "        /* c2 */\n"
+     "        ,  /* c1 */\n"
+     "        /* c2 */\n"
+     "        arg2  /* c1 */\n"
+     "        /* c2 */\n"
+     "    )  /* c1 */\n"
+     "/* c2 */\n"
+     ";  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz// c1\n"
+     "/* c2 */\n"
+     "(// c1\n"
+     "/* c2 */\n"
+     "arg1// c1\n"
+     "/* c2 */\n"
+     ",// c1\n"
+     "/* c2 */\n"
+     "arg2// c1\n"
+     "/* c2 */\n"
+     ")// c1\n"
+     "/* c2 */\n"
+     ";// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    /* c2 */\n"
+     "    (  // c1\n"
+     "        /* c2 */\n"
+     "        arg1  // c1\n"
+     "        /* c2 */\n"
+     "        ,  // c1\n"
+     "        /* c2 */\n"
+     "        arg2  // c1\n"
+     "        /* c2 */\n"
+     "    )  // c1\n"
+     "/* c2 */\n"
+     ";  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */\n"
+     "// c2\n"
+     "(/* c1 */\n"
+     "// c2\n"
+     "arg1/* c1 */\n"
+     "// c2\n"
+     ",/* c1 */\n"
+     "// c2\n"
+     "arg2/* c1 */\n"
+     "// c2\n"
+     ")/* c1 */\n"
+     "// c2\n"
+     ";/* c1 */\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    // c2\n"
+     "    (  /* c1 */\n"
+     "        // c2\n"
+     "        arg1  /* c1 */\n"
+     "        // c2\n"
+     "        ,  /* c1 */\n"
+     "        // c2\n"
+     "        arg2  /* c1 */\n"
+     "        // c2\n"
+     "    )  /* c1 */\n"
+     "// c2\n"
+     ";  /* c1 */\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz// c1\n"
+     "// c2\n"
+     "(// c1\n"
+     "// c2\n"
+     "arg1// c1\n"
+     "// c2\n"
+     ",// c1\n"
+     "// c2\n"
+     "arg2// c1\n"
+     "// c2\n"
+     ")// c1\n"
+     "// c2\n"
+     ";// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    // c2\n"
+     "    (  // c1\n"
+     "       // c2\n"
+     "        arg1  // c1\n"
+     "        // c2\n"
+     "        ,  // c1\n"
+     "           // c2\n"
+     "        arg2  // c1\n"
+     "        // c2\n"
+     "    )  // c1\n"
+     "       // c2\n"
+     ";  // c1\n"
+     "   // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "arg1/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ",/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "arg2/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ")/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     "    (  /* c1 */\n"
+     "        /* c2 */\n"
+     "        /* c3 */\n"
+     "        arg1  /* c1 */\n"
+     "        /* c2 */\n"
+     "        /* c3 */\n"
+     "        ,  /* c1 */\n"
+     "        /* c2 */\n"
+     "        /* c3 */\n"
+     "        arg2  /* c1 */\n"
+     "        /* c2 */\n"
+     "        /* c3 */\n"
+     "    )  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz// c1\n"
+     "// c2\n"
+     "// c3\n"
+     "(// c1\n"
+     "// c2\n"
+     "// c3\n"
+     "arg1// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ",// c1\n"
+     "// c2\n"
+     "// c3\n"
+     "arg2// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ")// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";// c1\n"
+     "// c2\n"
+     "// c3\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "$foobarbaz  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     "    (  // c1\n"
+     "       // c2\n"
+     "       // c3\n"
+     "        arg1  // c1\n"
+     "        // c2\n"
+     "        // c3\n"
+     "        ,  // c1\n"
+     "           // c2\n"
+     "           // c3\n"
+     "        arg2  // c1\n"
+     "        // c2\n"
+     "        // c3\n"
+     "    )  // c1\n"
+     "       // c2\n"
+     "       // c3\n"
+     ";  // c1\n"
+     "   // c2\n"
+     "   // c3\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c */arg1/* c */,/* c */arg2/* c */)/* c */;/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c */\n"
+     "    arg1  /* c */,  /* c */\n"
+     "    arg2  /* c */)  /* c */;  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ /* c2 */arg1/* c1 */ /* c2 */,/* c1 */ /* c2 "
+     "*/arg2/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  /* c2 */\n"
+     "    arg1  /* c1 */  /* c2 */,  /* c1 */  /* c2 */\n"
+     "    arg2  /* c1 */  /* c2 */)  /* c1 */  /* c2 */;  /* c1 */  /* c2 "
+     "*/\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c */\n"
+     "arg1/* c */\n"
+     ",/* c */\n"
+     "arg2/* c */\n"
+     ")/* c */\n"
+     ";/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c */\n"
+     "    arg1  /* c */\n"
+     "    ,  /* c */\n"
+     "    arg2  /* c */\n"
+     ")  /* c */\n"
+     ";  /* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ /* c2 */\n"
+     "arg1/* c1 */ /* c2 */\n"
+     ",/* c1 */ /* c2 */\n"
+     "arg2/* c1 */ /* c2 */\n"
+     ")/* c1 */ /* c2 */\n"
+     ";/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  /* c2 */\n"
+     "    arg1  /* c1 */  /* c2 */\n"
+     "    ,  /* c1 */  /* c2 */\n"
+     "    arg2  /* c1 */  /* c2 */\n"
+     ")  /* c1 */  /* c2 */\n"
+     ";  /* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c\n"
+     "arg1// c\n"
+     ",// c\n"
+     "arg2// c\n"
+     ")// c\n"
+     ";// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c\n"
+     "    arg1  // c\n"
+     "    ,  // c\n"
+     "    arg2  // c\n"
+     ")  // c\n"
+     ";  // c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */ // c2\n"
+     "arg1/* c1 */ // c2\n"
+     ",/* c1 */ // c2\n"
+     "arg2/* c1 */ // c2\n"
+     ")/* c1 */ // c2\n"
+     ";/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */  // c2\n"
+     "    arg1  /* c1 */  // c2\n"
+     "    ,  /* c1 */  // c2\n"
+     "    arg2  /* c1 */  // c2\n"
+     ")  /* c1 */  // c2\n"
+     ";  /* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c */arg1\n"
+     "/* c */,\n"
+     "/* c */arg2\n"
+     "/* c */)\n"
+     "/* c */;\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c */ arg1\n"
+     "    /* c */,\n"
+     "    /* c */ arg2\n"
+     "/* c */)\n"
+     "/* c */;\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ /* c2 */arg1\n"
+     "/* c1 */ /* c2 */,\n"
+     "/* c1 */ /* c2 */arg2\n"
+     "/* c1 */ /* c2 */)\n"
+     "/* c1 */ /* c2 */;\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */  /* c2 */ arg1\n"
+     "    /* c1 */  /* c2 */,\n"
+     "    /* c1 */  /* c2 */ arg2\n"
+     "/* c1 */  /* c2 */)\n"
+     "/* c1 */  /* c2 */;\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c */\n"
+     "arg1\n"
+     "/* c */\n"
+     ",\n"
+     "/* c */\n"
+     "arg2\n"
+     "/* c */\n"
+     ")\n"
+     "/* c */\n"
+     ";\n"
+     "/* c */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c */\n"
+     "    arg1\n"
+     "    /* c */\n"
+     "    ,\n"
+     "    /* c */\n"
+     "    arg2\n"
+     "    /* c */\n"
+     ")\n"
+     "/* c */\n"
+     ";\n"
+     "/* c */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ /* c2 */\n"
+     "arg1\n"
+     "/* c1 */ /* c2 */\n"
+     ",\n"
+     "/* c1 */ /* c2 */\n"
+     "arg2\n"
+     "/* c1 */ /* c2 */\n"
+     ")\n"
+     "/* c1 */ /* c2 */\n"
+     ";\n"
+     "/* c1 */ /* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */  /* c2 */\n"
+     "    arg1\n"
+     "    /* c1 */  /* c2 */\n"
+     "    ,\n"
+     "    /* c1 */  /* c2 */\n"
+     "    arg2\n"
+     "    /* c1 */  /* c2 */\n"
+     ")\n"
+     "/* c1 */  /* c2 */\n"
+     ";\n"
+     "/* c1 */  /* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "// c\n"
+     "arg1\n"
+     "// c\n"
+     ",\n"
+     "// c\n"
+     "arg2\n"
+     "// c\n"
+     ")\n"
+     "// c\n"
+     ";\n"
+     "// c\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    // c\n"
+     "    arg1\n"
+     "    // c\n"
+     "    ,\n"
+     "    // c\n"
+     "    arg2\n"
+     "    // c\n"
+     ")\n"
+     "// c\n"
+     ";\n"
+     "// c\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */ // c2\n"
+     "arg1\n"
+     "/* c1 */ // c2\n"
+     ",\n"
+     "/* c1 */ // c2\n"
+     "arg2\n"
+     "/* c1 */ // c2\n"
+     ")\n"
+     "/* c1 */ // c2\n"
+     ";\n"
+     "/* c1 */ // c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */  // c2\n"
+     "    arg1\n"
+     "    /* c1 */  // c2\n"
+     "    ,\n"
+     "    /* c1 */  // c2\n"
+     "    arg2\n"
+     "    /* c1 */  // c2\n"
+     ")\n"
+     "/* c1 */  // c2\n"
+     ";\n"
+     "/* c1 */  // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "arg1\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ",\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     "arg2\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ")\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"
+     "/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     "    arg1\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     "    ,\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     "    arg2\n"
+     "    /* c1 */\n"
+     "    /* c2 */\n"
+     ")\n"
+     "/* c1 */\n"
+     "/* c2 */\n"
+     ";\n"
+     "/* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "// c1\n"
+     "// c2\n"
+     "arg1\n"
+     "// c1\n"
+     "// c2\n"
+     ",\n"
+     "// c1\n"
+     "// c2\n"
+     "arg2\n"
+     "// c1\n"
+     "// c2\n"
+     ")\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"
+     "// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(\n"
+     "    // c1\n"
+     "    // c2\n"
+     "    arg1\n"
+     "    // c1\n"
+     "    // c2\n"
+     "    ,\n"
+     "    // c1\n"
+     "    // c2\n"
+     "    arg2\n"
+     "    // c1\n"
+     "    // c2\n"
+     ")\n"
+     "// c1\n"
+     "// c2\n"
+     ";\n"
+     "// c1\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */arg1/* c1 */\n"
+     "/* c2 */,/* c1 */\n"
+     "/* c2 */arg2/* c1 */\n"
+     "/* c2 */)/* c1 */\n"
+     "/* c2 */;/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */ arg1  /* c1 */\n"
+     "    /* c2 */,  /* c1 */\n"
+     "    /* c2 */ arg2  /* c1 */\n"
+     "/* c2 */)  /* c1 */\n"
+     "/* c2 */;  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "/* c2 */arg1// c1\n"
+     "/* c2 */,// c1\n"
+     "/* c2 */arg2// c1\n"
+     "/* c2 */)// c1\n"
+     "/* c2 */;// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    /* c2 */ arg1  // c1\n"
+     "    /* c2 */,  // c1\n"
+     "    /* c2 */ arg2  // c1\n"
+     "/* c2 */)  // c1\n"
+     "/* c2 */;  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */arg1/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */,/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */arg2/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */)/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */ arg1  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */,  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */ arg2  /* c1 */\n"
+     "    /* c2 */\n"
+     "/* c3 */)  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */;  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     "arg1/* c1 */\n"
+     "/* c2 */\n"
+     ",/* c1 */\n"
+     "/* c2 */\n"
+     "arg2/* c1 */\n"
+     "/* c2 */\n"
+     ")/* c1 */\n"
+     "/* c2 */\n"
+     ";/* c1 */\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    arg1  /* c1 */\n"
+     "    /* c2 */\n"
+     "    ,  /* c1 */\n"
+     "    /* c2 */\n"
+     "    arg2  /* c1 */\n"
+     "    /* c2 */\n"
+     ")  /* c1 */\n"
+     "/* c2 */\n"
+     ";  /* c1 */\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "/* c2 */\n"
+     "arg1// c1\n"
+     "/* c2 */\n"
+     ",// c1\n"
+     "/* c2 */\n"
+     "arg2// c1\n"
+     "/* c2 */\n"
+     ")// c1\n"
+     "/* c2 */\n"
+     ";// c1\n"
+     "/* c2 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    /* c2 */\n"
+     "    arg1  // c1\n"
+     "    /* c2 */\n"
+     "    ,  // c1\n"
+     "    /* c2 */\n"
+     "    arg2  // c1\n"
+     "    /* c2 */\n"
+     ")  // c1\n"
+     "/* c2 */\n"
+     ";  // c1\n"
+     "/* c2 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "// c2\n"
+     "arg1/* c1 */\n"
+     "// c2\n"
+     ",/* c1 */\n"
+     "// c2\n"
+     "arg2/* c1 */\n"
+     "// c2\n"
+     ")/* c1 */\n"
+     "// c2\n"
+     ";/* c1 */\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    // c2\n"
+     "    arg1  /* c1 */\n"
+     "    // c2\n"
+     "    ,  /* c1 */\n"
+     "    // c2\n"
+     "    arg2  /* c1 */\n"
+     "    // c2\n"
+     ")  /* c1 */\n"
+     "// c2\n"
+     ";  /* c1 */\n"
+     "// c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "// c2\n"
+     "arg1// c1\n"
+     "// c2\n"
+     ",// c1\n"
+     "// c2\n"
+     "arg2// c1\n"
+     "// c2\n"
+     ")// c1\n"
+     "// c2\n"
+     ";// c1\n"
+     "// c2\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    // c2\n"
+     "    arg1  // c1\n"
+     "    // c2\n"
+     "    ,  // c1\n"
+     "       // c2\n"
+     "    arg2  // c1\n"
+     "    // c2\n"
+     ")  // c1\n"
+     "   // c2\n"
+     ";  // c1\n"
+     "   // c2\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "arg1/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ",/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     "arg2/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ")/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";/* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     "    arg1  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     "    ,  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     "    arg2  /* c1 */\n"
+     "    /* c2 */\n"
+     "    /* c3 */\n"
+     ")  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"
+     ";  /* c1 */\n"
+     "/* c2 */\n"
+     "/* c3 */\n"},
+    {"// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(// c1\n"
+     "// c2\n"
+     "// c3\n"
+     "arg1// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ",// c1\n"
+     "// c2\n"
+     "// c3\n"
+     "arg2// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ")// c1\n"
+     "// c2\n"
+     "// c3\n"
+     ";// c1\n"
+     "// c2\n"
+     "// c3\n",
+     "// verilog_syntax: parse-as-module-body\n"
+     "`FOOBARBAZ(  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     "    arg1  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     "    ,  // c1\n"
+     "       // c2\n"
+     "       // c3\n"
+     "    arg2  // c1\n"
+     "    // c2\n"
+     "    // c3\n"
+     ")  // c1\n"
+     "   // c2\n"
+     "   // c3\n"
+     ";  // c1\n"
+     "   // c2\n"
+     "   // c3\n"},
+    {"module indent();\n"
+     "   reg     a;\n"
+     "   reg [32:0] b;\n"
+     "   wire    c;\n"
+     "   wire    d = e ? kFoo : kBar;\n"
+     "endmodule\n",
+     "module indent ();\n"
+     "  reg         a;\n"
+     "  reg  [32:0] b;\n"
+     "  wire        c;\n"
+     "  wire        d = e ? kFoo : kBar;\n"
+     "endmodule\n"},
+
+    {"class C; T1 b; logic [$] a; T1 [$] c; endclass\n",
+     "class C;\n"
+     "  T1        b;\n"
+     "  logic [$] a;\n"
+     "  T1    [$] c;\n"
+     "endclass\n"},
+    {"class C;\n"
+     "  T1 b; //test\n"
+     "  logic [$] a; //test\n"
+     "  T1    [$] c; //test\n"
+     "endclass\n",
+     "class C;\n"
+     "  T1        b;  //test\n"
+     "  logic [$] a;  //test\n"
+     "  T1    [$] c;  //test\n"
+     "endclass\n"},
+    {"class C;\n"
+     "  T1\n"
+     "  b;\n"
+     "  logic\n"
+     "  [$]\n"
+     "  a;\n"
+     "  T1\n"
+     "  [$]\n"
+     "  c;\n"
+     "endclass\n",
+     "class C;\n"
+     "  T1        b;\n"
+     "  logic [$] a;\n"
+     "  T1    [$] c;\n"
+     "endclass\n"},
+    {"class C;\n"
+     "  logic/*t*/ [0 : 1] /*t*/\n"
+     "  a;/*t*/\n"
+     "  T1/*t*/[0 : 1]/*t*/\n"
+     "  c;/*t*/\n"
+     "endclass\n",
+     "class C;\n"
+     "  logic/*t*/ [0 : 1]  /*t*/ a;  /*t*/\n"
+     "  T1/*t*/    [0 : 1]  /*t*/ c;  /*t*/\n"
+     "endclass\n"},
+    {"always @(*/*t*/) begin\n"
+     "end\n",
+     "always @(*  /*t*/) begin\n"
+     "end\n"},
+    {"always @(/*t*/*) begin\n"
+     "end\n",
+     "always @(  /*t*/ *) begin\n"
+     "end\n"},
+    {"always @(/*t*/*/*t*/) begin\n"
+     "end\n",
+     "always @(  /*t*/ *  /*t*/) begin\n"
+     "end\n"},
+    {"always @(*) begin\n"
+     "end\n",
+     "always @(*) begin\n"
+     "end\n"},
+    {"always @(* ) begin\n"
+     "end\n",
+     "always @(*) begin\n"
+     "end\n"},
+    {"always @( *) begin\n"
+     "end\n",
+     "always @(*) begin\n"
+     "end\n"},
+    {"always @( * ) begin\n"
+     "end\n",
+     "always @(*) begin\n"
+     "end\n"},
+    {"always @(  /*t*/  *   /*t*/    ) begin\n"
+     "end\n",
+     "always @(  /*t*/ *  /*t*/) begin\n"
+     "end\n"},
+    {
+        // Don't touch verilog_format:off region #1538
+        R"(
+module testcode;
+  // verilog_format: off
+  assign a = b
+           & c;
+  // verilog_format: on
+      assign e = d;
+endmodule
+)",
+        R"(
+module testcode;
+  // verilog_format: off
+  assign a = b
+           & c;
+  // verilog_format: on
+  assign e = d;
+endmodule
+)",
+
+    },
+
+    // -----------------------------------------------------------------
+};
+
+TEST(FormatterEndToEndTest, DisableFormatterTestCases) {
+  RunFormatterTestCases40(kDisableFormatterTestCases);
+}
+
+}  // namespace
+}  // namespace formatter
+}  // namespace verilog
diff --git a/verible/verilog/formatting/formatter_function_task_test.cc b/verible/verilog/formatting/formatter_function_task_test.cc
new file mode 100644
index 0000000..88e30bb
--- /dev/null
+++ b/verible/verilog/formatting/formatter_function_task_test.cc
@@ -0,0 +1,2234 @@
+// Copyright 2017-2026 The Verible Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Test cases in this file should be *insensitive* to wrapping penalties.
+// Penalty-sensitive tests belong in formatter-tuning_test.cc.
+
+#include "gtest/gtest.h"
+#include "verible/verilog/formatting/formatter-test-utils.h"
+
+namespace verilog {
+namespace formatter {
+namespace {
+
+static constexpr FormatterTestCase kFunctionTaskFormatterTestCases[] = {
+    // function test cases
+    {"function f ;endfunction", "function f;\nendfunction\n"},
+    {"function f ;endfunction:   f", "function f;\nendfunction : f\n"},
+    {"function f ( );endfunction", "function f();\nendfunction\n"},
+    {"function f (input bit x);endfunction",
+     "function f(input bit x);\nendfunction\n"},
+    {"function f (input bit x,logic y );endfunction",
+     "function f(input bit x, logic y);\nendfunction\n"},
+    {"function f;\n// statement comment\nendfunction\n",
+     "function f;\n"
+     "  // statement comment\n"  // indented
+     "endfunction\n"},
+    {"function f();\n// statement comment\nendfunction\n",
+     "function f();\n"
+     "  // statement comment\n"  // indented
+     "endfunction\n"},
+    {"function f(input int x);\n"
+     "// statement comment\n"
+     "f=x;\n"
+     "// statement comment\n"
+     "endfunction\n",
+     "function f(input int x);\n"
+     "  // statement comment\n"  // indented
+     "  f = x;\n"
+     "  // statement comment\n"  // indented
+     "endfunction\n"},
+    {// line breaks around assignments
+     "function f;a=b;c+=d;endfunction",
+     "function f;\n"
+     "  a = b;\n"
+     "  c += d;\n"
+     "endfunction\n"},
+    {"function f;a&=b;c=d;endfunction",
+     "function f;\n"
+     "  a &= b;\n"
+     "  c = d;\n"
+     "endfunction\n"},
+    {"function f;a<<=b;c=b;d>>>=b;endfunction",
+     "function f;\n"
+     "  a <<= b;\n"
+     "  c = b;\n"
+     "  d >>>= b;\n"
+     "endfunction\n"},
+    {// port declaration exceeds line length limit
+     "function f (loooong_type if_it_fits_I_sits);endfunction",
+     "function f(\n"
+     "    loooong_type if_it_fits_I_sits);\n"
+     "endfunction\n"},
+    {"function\nvoid\tspace;a=( b+c )\n;endfunction   :space\n",
+     "function void space;\n"
+     "  a = (b + c);\n"
+     "endfunction : space\n"},
+    {"function\nvoid\twarranty;return  to_sender\n;endfunction   :warranty\n",
+     "function void warranty;\n"
+     "  return to_sender;\n"
+     "endfunction : warranty\n"},
+    {// if statement that fits on one line
+     "function if_i_fits_i_sits;"
+     "if(x)y=x;"
+     "endfunction",
+     "function if_i_fits_i_sits;\n"
+     "  if (x) y = x;\n"
+     "endfunction\n"},
+    {// for loop
+     "function\nvoid\twarranty;for(j=0; j<k; --k)begin "
+     "++j\n;end endfunction   :warranty\n",
+     "function void warranty;\n"
+     "  for (j = 0; j < k; --k) begin\n"
+     "    ++j;\n"
+     "  end\n"
+     "endfunction : warranty\n"},
+    {// for loop that needs wrapping
+     "function\nvoid\twarranty;for(jjjjj=0; jjjjj<kkkkk; --kkkkk)begin "
+     "++j\n;end endfunction   :warranty\n",
+     "function void warranty;\n"
+     "  for (\n"
+     "      jjjjj = 0; jjjjj < kkkkk; --kkkkk\n"
+     "  ) begin\n"
+     "    ++j;\n"
+     "  end\n"
+     "endfunction : warranty\n"},
+    {// for loop that needs more wrapping
+     "function\nvoid\twarranty;"
+     "for(jjjjjjjj=0; jjjjjjjj<kkkkkkkk; --kkkkkkkk)begin "
+     "++j\n;end endfunction   :warranty\n",
+     "function void warranty;\n"
+     "  for (\n"
+     "      jjjjjjjj = 0;\n"
+     "      jjjjjjjj < kkkkkkkk;\n"
+     "      --kkkkkkkk\n"
+     "  ) begin\n"
+     "    ++j;\n"
+     "  end\n"
+     "endfunction : warranty\n"},
+    {// for loop that fits on one line
+     "function loop_fits;"
+     "for(x=0;x<N;++x) y=x;"
+     "endfunction",
+     "function loop_fits;\n"
+     "  for (x = 0; x < N; ++x) y = x;\n"
+     "endfunction\n"},
+    {// for loop that would fit on one line, but is force-split with //comment
+     "function loop_fits;"
+     "for(x=0;x<N;++x) //\n y=x;"
+     "endfunction",
+     "function loop_fits;\n"
+     "  for (x = 0; x < N; ++x)  //\n"
+     "    y = x;\n"
+     "endfunction\n"},
+    {// for loop with function call in initializer
+     "function  void looper(); "
+     "for (int i=f(n); i>=0; i -- ) begin end "
+     "endfunction",
+     "function void looper();\n"
+     "  for (int i = f(n); i >= 0; i--) begin\n"
+     "  end\n"
+     "endfunction\n"},
+    {// for loop with function call in condition
+     "function  void looper(); "
+     "for (int i=0; i<f(m); i -- ) begin end "
+     "endfunction",
+     "function void looper();\n"
+     "  for (int i = 0; i < f(m); i--) begin\n"
+     "  end\n"
+     "endfunction\n"},
+    {// for loop with an attribute instance in the initializer.
+     // Regression: this used to abort with a CHECK failure while reshaping
+     // the kForSpec partitions when an attribute appears in the header.
+     "module m; initial for(int i=0(* a *);i<4;i++) x=i; endmodule",
+     "module m;\n"
+     "  initial\n"
+     "    for (int i = 0 (* a *); i < 4; i++)\n"
+     "      x = i;\n"
+     "endmodule\n"},
+    {// forever loop
+     "function\nvoid\tforevah;forever  begin "
+     "++k\n;end endfunction\n",
+     "function void forevah;\n"
+     "  forever begin\n"
+     "    ++k;\n"
+     "  end\n"
+     "endfunction\n"},
+    {// forever loop
+     "function\nvoid\tforevah;forever  "
+     "++k\n;endfunction\n",
+     "function void forevah;\n"
+     "  forever ++k;\n"
+     "endfunction\n"},
+    {// forever loop, forced break
+     "function\nvoid\tforevah;forever     //\n"
+     "++k\n;endfunction\n",
+     "function void forevah;\n"
+     "  forever  //\n"
+     "    ++k;\n"
+     "endfunction\n"},
+    {// repeat loop
+     "function\nvoid\tpete;repeat(3)  begin "
+     "++k\n;end endfunction\n",
+     "function void pete;\n"
+     "  repeat (3) begin\n"
+     "    ++k;\n"
+     "  end\n"
+     "endfunction\n"},
+    {// repeat loop
+     "function\nvoid\tpete;repeat(3)  "
+     "++k\n;endfunction\n",
+     "function void pete;\n"
+     "  repeat (3)++k;\n"  // TODO(fangism): space before ++
+     "endfunction\n"},
+    {// repeat loop, forced break
+     "function\nvoid\tpete;repeat(3)//\n"
+     "++k\n;endfunction\n",
+     "function void pete;\n"
+     "  repeat (3)  //\n"
+     "    ++k;\n"
+     "endfunction\n"},
+    {// while loop
+     "function\nvoid\twily;while( coyote )  begin "
+     "++super_genius\n;end endfunction\n",
+     "function void wily;\n"
+     "  while (coyote) begin\n"
+     "    ++super_genius;\n"
+     "  end\n"
+     "endfunction\n"},
+    {// while loop
+     "function\nvoid\twily;while( coyote )  "
+     "++ super_genius\n;   endfunction\n",
+     "function void wily;\n"
+     "  while (coyote)++super_genius;\n"  // TODO(fangism): space before ++
+     "endfunction\n"},
+    {// while loop, forced break
+     "function\nvoid\twily;while( coyote ) //\n "
+     "++ super_genius\n;   endfunction\n",
+     "function void wily;\n"
+     "  while (coyote)  //\n"
+     "    ++super_genius;\n"
+     "endfunction\n"},
+    {// do-while loop
+     "function\nvoid\tdonot;do  begin "
+     "++s\n;end  while( z);endfunction\n",
+     "function void donot;\n"
+     "  do begin\n"
+     "    ++s;\n"
+     "  end while (z);\n"
+     "endfunction\n"},
+    {// do-while loop, single statement
+     "function\nvoid\tdonot;do  "
+     "++s\n;  while( z);endfunction\n",
+     "function void donot;\n"
+     "  do ++s; while (z);\n"
+     "endfunction\n"},
+    {// do-while loop, single statement, forced break
+     "function\nvoid\tdonot;do  "
+     "++s\n;//\n  while( z);endfunction\n",
+     "function void donot;\n"
+     "  do\n"
+     "    ++s;  //\n"
+     "  while (z);\n"
+     "endfunction\n"},
+    {// foreach loop
+     "function\nvoid\tforeacher;foreach( m [n] )  begin "
+     "++m\n;end endfunction\n",
+     "function void foreacher;\n"
+     "  foreach (m[n]) begin\n"
+     "    ++m;\n"
+     "  end\n"
+     "endfunction\n"},
+    {// spaces in condition expression
+     "function f; return {a}? {b} :{ c };endfunction",
+     "function f;\n"
+     "  return {a} ? {b} : {c};\n"
+     "endfunction\n"},
+    {"task t;endtask",
+     "task t;\n"
+     "endtask\n"},
+    {"task t (   );endtask",
+     "task t();\n"
+     "endtask\n"},
+    {"task t (input    bit   drill   ) ;endtask",
+     "task t(input bit drill);\n"
+     "endtask\n"},
+    {"task t; ## 100 ;endtask",
+     "task t;\n"
+     "  ##100;\n"
+     "endtask\n"},
+    {"task t; ## (1+1) ;endtask",  // delay expression
+     "task t;\n"
+     "  ##(1 + 1);\n"
+     "endtask\n"},
+    {"task t; ## delay_value ;endtask",
+     "task t;\n"
+     "  ##delay_value;\n"
+     "endtask\n"},
+    {"task t; ## `DELAY_VALUE ;endtask",
+     "task t;\n"
+     "  ##`DELAY_VALUE;\n"
+     "endtask\n"},
+    {"task t;\n"
+     "`uvm_error( foo,bar);\n"
+     "endtask\n",
+     "task t;\n"
+     "  `uvm_error(foo, bar);\n"
+     "endtask\n"},
+    {"task t;\n"
+     "`uvm_error(foo,bar)\n"
+     ";\n"  // null statement
+     "endtask\n",
+     "task t;\n"
+     "  `uvm_error(foo, bar)\n"
+     "  ;\n"
+     "endtask\n"},
+    {"task t;\n"
+     "if(expr)begin\t\n"
+     "`uvm_error(foo,bar);\n"
+     "end\n"
+     "endtask\n",
+     "task t;\n"
+     "  if (expr) begin\n"
+     "    `uvm_error(foo, bar);\n"
+     "  end\n"
+     "endtask\n"},
+    {"task\nrabbit;$kill(the,\nrabbit)\n;endtask:  rabbit\n",
+     "task rabbit;\n"
+     "  $kill(the, rabbit);\n"
+     "endtask : rabbit\n"},
+    {"function  int foo( );if( a )a+=1 ; endfunction",
+     "function int foo();\n"
+     "  if (a) a += 1;\n"
+     "endfunction\n"},
+    {"function  void foo( );foo=`MACRO(b,c) ; endfunction",
+     "function void foo();\n"
+     "  foo = `MACRO(b, c);\n"
+     "endfunction\n"},
+    {"module foo;if    \t  (bar)begin assign a=1; end endmodule",
+     "module foo;\n"
+     "  if (bar) begin\n"
+     "    assign a = 1;\n"
+     "  end\n"
+     "endmodule\n"},
+    {"module proc_cont_assigner;\n"
+     "always begin\n"
+     "assign x1 =   y1;\n"
+     "deassign   x2 ;\n"
+     "force x3=y3;\n"
+     "release   x4 ;\n"
+     "end\n"
+     "endmodule\n",
+     "module proc_cont_assigner;\n"
+     "  always begin\n"
+     "    assign x1 = y1;\n"
+     "    deassign x2;\n"
+     "    force x3 = y3;\n"
+     "    release x4;\n"
+     "  end\n"
+     "endmodule\n"},
+    {"module g_test(  );\n"
+     "\tinitial begin:main_test \t"
+     "for(int i=0;i<k;i++)begin "
+     "case(i )\n"
+     " 6'd0  :release in[0];  \n"
+     "   endcase  "
+     " \t\tend \t"
+     "\t end:main_test\n"
+     "endmodule:g_test\n",
+     "module g_test ();\n"
+     "  initial begin : main_test\n"
+     "    for (int i = 0; i < k; i++) begin\n"
+     "      case (i)\n"
+     "        6'd0: release in[0];\n"
+     "      endcase\n"
+     "    end\n"
+     "  end : main_test\n"
+     "endmodule : g_test\n"},
+    {// conditional generate (case)
+     "module mc; case(s)a : bb c ; d : ee f; endcase endmodule",
+     "module mc;\n"
+     "  case (s)\n"
+     "    a: bb c;\n"
+     "    d: ee f;\n"
+     "  endcase\n"
+     "endmodule\n"},
+    {// conditional generate (case), with comments
+     "module mc; case(s)\n//comment a\na:bb  c;\n//comment b\n endcase "
+     "endmodule",
+     "module mc;\n"
+     "  case (s)\n"
+     "    //comment a\n"  // indented to case-item level
+     "    a: bb c;\n"
+     "    //comment b\n"  // indented to case-item level
+     "  endcase\n"
+     "endmodule\n"},
+
+    {// "default:", not "default :"
+     "function f; case (x) default: x=y; endcase endfunction\n",
+     "function f;\n"
+     "  case (x)\n"
+     "    default: x = y;\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// default with null statement: "default: ;", not "default :;"
+     "function f; case (x) default :; endcase endfunction\n",
+     "function f;\n"
+     "  case (x)\n"
+     "    default: ;\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// case statement
+     "function f; case (x) State0 : a=b; State1 : begin a=b; end "
+     "endcase endfunction\n",
+     "function f;\n"
+     "  case (x)\n"
+     "    State0: a = b;\n"
+     "    State1: begin\n"
+     "      a = b;\n"
+     "    end\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// case statement, interleaved with comments
+     "function f; case (x) \n//c1\nState0 : a=b;//c2\n//c3\n State1 : "
+     "a=b;//c4\n//c5\n "
+     "endcase endfunction\n",
+     "function f;\n"
+     "  case (x)\n"
+     "    //c1\n"
+     "    State0: a = b;  //c2\n"
+     "    //c3\n"
+     "    State1: a = b;  //c4\n"
+     "    //c5\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// case inside statement, comments
+     "function f; case (x)inside \n//comment\n"
+     "[0:1]:x=y; \n"
+     "    //comment\n"
+     "endcase endfunction\n",
+     "function f;\n"
+     "  case (x) inside\n"
+     "    //comment\n"
+     "    [0 : 1]: x = y;\n"
+     "    //comment\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// case inside statement
+     "function f; case (x)inside k1 : return b; k2 : begin return b; end "
+     "endcase endfunction\n",
+     "function f;\n"
+     "  case (x) inside\n"
+     "    k1: return b;\n"
+     "    k2: begin\n"
+     "      return b;\n"
+     "    end\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// case inside statement, with ranges
+     "function f; case (x) inside[a:b] : return b; [c:d] : return b; "
+     "default :return z;"
+     "endcase endfunction\n",
+     "function f;\n"
+     "  case (x) inside\n"
+     "    [a : b]: return b;\n"
+     "    [c : d]: return b;\n"
+     "    default: return z;\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// case pattern statement
+     "function f;"
+     "case (y) matches "
+     ".foo   : return 0;"
+     ".*\t: return 1;"
+     "endcase "
+     "case (z) matches "
+     ".foo\t\t: return 0;"
+     ".*   : return 1;"
+     "endcase "
+     "endfunction",
+     "function f;\n"
+     "  case (y) matches\n"
+     "    .foo: return 0;\n"
+     "    .*: return 1;\n"
+     "  endcase\n"
+     "  case (z) matches\n"
+     "    .foo: return 0;\n"
+     "    .*: return 1;\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// keep short case items on one line
+     "function f; case (x)k1 : if( b )break; default :return 2;"
+     "endcase endfunction\n",
+     "function f;\n"
+     "  case (x)\n"
+     "    k1:      if (b) break;\n"  // aligned
+     "    default: return 2;\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// keep short default items on one line
+     "function f; case (x)k1 :break; default :if( c )return 2;"
+     "endcase endfunction\n",
+     "function f;\n"
+     "  case (x)\n"
+     "    k1:      break;\n"  // aligned
+     "    default: if (c) return 2;\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// keep short case inside items on one line
+     "function f; case (x)inside k1 : if( b )return c; k2 : return a;"
+     "endcase endfunction\n",
+     "function f;\n"
+     "  case (x) inside\n"
+     "    k1: if (b) return c;\n"
+     "    k2: return a;\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// keep short case pattern items on one line
+     "function f;"
+     "case (y) matches "
+     ".foo   :if( n )return 0;"
+     ".*\t: return 1;"
+     "endcase "
+     "endfunction",
+     "function f;\n"
+     "  case (y) matches\n"
+     "    .foo: if (n) return 0;\n"
+     "    .*: return 1;\n"
+     "  endcase\n"
+     "endfunction\n"},
+    {// randcase
+     "function f; randcase k1 : return c; k2 : return a;"
+     "endcase endfunction\n",
+     "function f;\n"
+     "  randcase\n"
+     "    k1: return c;\n"
+     "    k2: return a;\n"
+     "  endcase\n"
+     "endfunction\n"},
+
+    // This tests checks for not breaking around hierarchy operators.
+    {"function\nvoid\twarranty;"
+     "foo.bar = fancyfunction(aaaaaaaa.bbbbbbb,"
+     "    ccccccccc.ddddddddd) ;"
+     "endfunction   :warranty\n",
+     "function void warranty;\n"
+     "  foo.bar = fancyfunction(\n"
+     "      aaaaaaaa.bbbbbbb,\n"
+     "      ccccccccc.ddddddddd\n"
+     "  );\n"
+     "endfunction : warranty\n"},
+
+    // Group of tests testing partitioning of arguments inside function calls
+    {// function with function call inside if statement header
+     "function foo;if(aa(bb,cc));endfunction\n",
+     "function foo;\n"
+     "  if (aa(bb, cc));\n"
+     "endfunction\n"},
+    {// function with function call inside if statement header and with
+     // begin-end block
+     "function foo;if (aa(bb,cc,dd,ee))begin end endfunction\n",
+     "function foo;\n"
+     "  if (aa(bb, cc, dd, ee)) begin\n"
+     "  end\n"
+     "endfunction\n"},
+    {// function with kMethodCallExtension inside if statement header and with
+     // begin-end block
+     "function foo;if (aa.bb(cc,dd,ee))begin end endfunction\n",
+     "function foo;\n"
+     "  if (aa.bb(cc, dd, ee)) begin\n"
+     "  end\n"
+     "endfunction\n"},
+    {// nested kMethodCallExtension calls - one level
+     "function foo;aa.bb(cc.dd(a1), ee.ff(a2));endfunction\n",
+     "function foo;\n"
+     "  aa.bb(cc.dd(a1), ee.ff(a2));\n"
+     "endfunction\n"},
+    {// nested kMethodCallExtension calls - two level
+     "function foo;aa.bb(cc.dd(a1.b1(a2), b1), ee.ff(c1, d1));endfunction\n",
+     "function foo;\n"
+     "  aa.bb(cc.dd(a1.b1(a2), b1), ee.ff(\n"
+     "        c1, d1));\n"
+     "endfunction\n"},
+
+    {// simple initial statement with function call
+     "module m;initial aa(bb,cc,dd,ee);endmodule\n",
+     "module m;\n"
+     "  initial aa(bb, cc, dd, ee);\n"
+     "endmodule\n"},
+    {// expressions and function calls inside if-statement headers
+     "module m;initial begin if(aa(bb)==cc(dd))a=b;if (xx()) b = a;end "
+     "endmodule\n",
+     "module m;\n"
+     "  initial begin\n"
+     "    if (aa(bb) == cc(dd)) a = b;\n"
+     "    if (xx()) b = a;\n"
+     "  end\n"
+     "endmodule\n"},
+    {// fuction with two arguments inside if-statement headers
+     "module\nm;initial\nbegin\nif(aa(bb,cc))x=y;end\nendmodule\n",
+     "module m;\n"
+     "  initial begin\n"
+     "    if (aa(bb, cc)) x = y;\n"
+     "  end\n"
+     "endmodule\n"},
+    {// kMethodCallExtension inside if-statement headers
+     "module m;initial begin if (aa.bb(cc)) x = y;end endmodule",
+     "module m;\n"
+     "  initial begin\n"
+     "    if (aa.bb(cc)) x = y;\n"
+     "  end\n"
+     "endmodule\n"},
+    {// initial statement with object method call
+     "module m; initial a.b(a,b,c); endmodule\n",
+     "module m;\n"
+     "  initial a.b(a, b, c);\n"
+     "endmodule\n"},
+    {// initial statement with method call on indexed object
+     "module m; initial a[i].b(a,b,c); endmodule\n",
+     "module m;\n"
+     "  initial a[i].b(a, b, c);\n"
+     "endmodule\n"},
+    {// initial statement with method call on function returned object
+     "module m; initial a(d,e,f).b(a,b,c); endmodule\n",
+     "module m;\n"
+     "  initial a(d, e, f).b(a, b, c);\n"
+     "endmodule\n"},
+    {// initial statement with indexed access to function returned object
+     "module m; initial a(a,b,c)[i]; endmodule\n",
+     "module m;\n"
+     "  initial a(a, b, c) [i];\n"
+     "endmodule\n"},
+    {// method call with no arguments on an object
+     "module m; initial foo.bar();endmodule\n",
+     "module m;\n"
+     "  initial foo.bar();\n"
+     "endmodule\n"},
+    {// method call with one argument on an object
+     "module m; initial foo.bar(aa);endmodule\n",
+     "module m;\n"
+     "  initial foo.bar(aa);\n"
+     "endmodule\n"},
+    {// method call with two arguments on an object
+     "module m; initial foo.bar(aa,bb);endmodule\n",
+     "module m;\n"
+     "  initial foo.bar(aa, bb);\n"
+     "endmodule\n"},
+    {// method call with three arguments on an object
+     "module m; initial foo.bar(aa,bb,cc);endmodule\n",
+     "module m;\n"
+     "  initial foo.bar(aa, bb, cc);\n"
+     "endmodule\n"},
+
+    {
+        // This tests for if-statements with null statements
+        "function foo;"
+        "if (zz) ; "
+        "if (yy) ; "
+        "endfunction",
+        "function foo;\n"
+        "  if (zz);\n"
+        "  if (yy);\n"
+        "endfunction\n",
+    },
+
+    {
+        // This tests for if-statements starting on their own line.
+        "function foo;"
+        "if (zz) begin "
+        "return 0;"
+        "end "
+        "if (yy) begin "
+        "return 1;"
+        "end "
+        "endfunction",
+        "function foo;\n"
+        "  if (zz) begin\n"
+        "    return 0;\n"
+        "  end\n"
+        "  if (yy) begin\n"
+        "    return 1;\n"
+        "  end\n"
+        "endfunction\n",
+    },
+
+    {
+        // This tests for if-statements with single statement bodies
+        "function foo;"
+        "if (zz) return 0;"
+        "if (yy) return 1;"
+        "endfunction",
+        "function foo;\n"
+        "  if (zz) return 0;\n"
+        "  if (yy) return 1;\n"
+        "endfunction\n",
+    },
+
+    {
+        // This tests for if-statement mixed with plain statements
+        "function foo;"
+        "a=b;"
+        "if (zz) return 0;"
+        "c=d;"
+        "endfunction",
+        "function foo;\n"
+        "  a = b;\n"
+        "  if (zz) return 0;\n"
+        "  c = d;\n"
+        "endfunction\n",
+    },
+
+    {
+        // This tests for if-statement with forced break mixed with others
+        "function foo;"
+        "a=b;"
+        "if (zz)//\n return 0;"
+        "c=d;"
+        "endfunction",
+        "function foo;\n"
+        "  a = b;\n"
+        "  if (zz)  //\n"
+        "    return 0;\n"
+        "  c = d;\n"
+        "endfunction\n",
+    },
+    {
+        "function t;"
+        "if (r == t)"
+        "a.b(c);"
+        "endfunction",
+        "function t;\n"
+        "  if (r == t) a.b(c);\n"
+        "endfunction\n",
+    },
+
+    {// This tests for for-statement with forced break mixed with others
+     "function f;"
+     "x=y;"
+     "for (int i=0; i<S*IPS; i++) #1ps a += $urandom();"
+     "return 2;"
+     "endfunction",
+     "function f;\n"
+     "  x = y;\n"
+     "  for (int i = 0; i < S * IPS; i++)\n"  // doesn't fit, so indents
+     "    #1ps a += $urandom();\n"
+     "  return 2;\n"
+     "endfunction\n"},
+
+    {
+        // This tests for-statements with null statements
+        "function foo;"
+        "for(;;)  ;\t"
+        "for(;;)  ;\t"
+        "endfunction",
+        "function foo;\n"
+        "  for (;;);\n"
+        "  for (;;);\n"
+        "endfunction\n",
+    },
+
+    {
+        // This tests for if-else-statements with null statements
+        "function foo;"
+        "if (zz) ;  else  ;"
+        "if (yy) ;   else   ;"
+        "endfunction",
+        "function foo;\n"
+        "  if (zz);\n"
+        "  else;\n"
+        "  if (yy);\n"
+        "  else;\n"
+        "endfunction\n",
+    },
+
+    {
+        // This tests for end-else-begin.
+        "function foo;"
+        "if (zz) begin "
+        "return 0;"
+        "end "
+        "else "
+        "begin "
+        "return 1;"
+        "end "
+        "endfunction",
+        "function foo;\n"
+        "  if (zz) begin\n"
+        "    return 0;\n"
+        "  end else begin\n"
+        "    return 1;\n"
+        "  end\n"
+        "endfunction\n",
+    },
+    {
+        // This tests for end-else-if
+        "function foo;"
+        "if (zz) begin "
+        "return 0;"
+        "end "
+        "else "
+        "if(yy)begin "
+        "return 1;"
+        "end "
+        "endfunction",
+        "function foo;\n"
+        "  if (zz) begin\n"
+        "    return 0;\n"
+        "  end else if (yy) begin\n"
+        "    return 1;\n"
+        "  end\n"
+        "endfunction\n",
+    },
+    {
+        // This tests labeled end-else-if
+        "function foo;"
+        "if (zz) begin : label1 "
+        "return 0;"
+        "end : label1 "
+        "else if (yy) begin : label2 "
+        "return 1;"
+        "end : label2 "
+        "endfunction",
+        "function foo;\n"
+        "  if (zz) begin : label1\n"
+        "    return 0;\n"
+        "  end : label1\n"
+        "  else if (yy) begin : label2\n"
+        "    return 1;\n"
+        "  end : label2\n"
+        "endfunction\n",
+    },
+    {
+        // This tests labeled end-else-if-else
+        "function foo;"
+        "if (zz) begin : label1 "
+        "return 0;"
+        "end : label1 "
+        "else if (yy) begin : label2 "
+        "return 1;"
+        "end : label2 "
+        "else begin : label3 "
+        "return 2;"
+        "end : label3 "
+        "endfunction",
+        "function foo;\n"
+        "  if (zz) begin : label1\n"
+        "    return 0;\n"
+        "  end : label1\n"
+        "  else if (yy) begin : label2\n"
+        "    return 1;\n"
+        "  end : label2\n"
+        "  else begin : label3\n"
+        "    return 2;\n"
+        "  end : label3\n"
+        "endfunction\n",
+    },
+
+    {
+        // randomize function
+        "function r ;"
+        "if ( ! randomize (bar )) begin    end "
+        "if ( ! obj.randomize (bar )) begin    end "
+        "endfunction",
+        "function r;\n"
+        "  if (!randomize(bar)) begin\n"
+        "  end\n"
+        "  if (!obj.randomize(bar)) begin\n"
+        "  end\n"
+        "endfunction\n",
+    },
+    {
+        // randomize-with call, with comments
+        "function f;"
+        "s = std::randomize() with {\n"
+        "// comment1\n"
+        "a == e;\n"
+        "// comment2\n"
+        "};"
+        "endfunction\n",
+        "function f;\n"
+        "  s = std::randomize() with {\n"
+        "    // comment1\n"
+        "    a == e;\n"
+        "    // comment2\n"
+        "  };\n"
+        "endfunction\n",
+    },
+    {
+        // randomize-with call, with comments, one joined
+        "function f;"
+        "s = std::randomize() with {\n"
+        "// comment1\n"
+        "a == e;// comment2\n"
+        "};"
+        "endfunction\n",
+        "function f;\n"
+        "  s = std::randomize() with {\n"
+        "    // comment1\n"
+        "    a == e;  // comment2\n"
+        "  };\n"
+        "endfunction\n",
+    },
+    {
+        // randomize-with call, with comment, and conditional
+        "function f;"
+        "s = std::randomize() with {\n"
+        "// comment\n"
+        "a == e;"
+        "if (x) {"
+        "a;"
+        "}"
+        "};"
+        "endfunction\n",
+        "function f;\n"
+        "  s = std::randomize() with {\n"
+        "    // comment\n"
+        "    a == e;\n"
+        "    if (x) {a;}\n"  // TODO(fangism): consider expanding
+        "  };\n"
+        "endfunction\n",
+    },
+
+    // module declaration test cases
+    {"   module       foo  ;     endmodule\n",
+     "module foo;\n"
+     "endmodule\n"},
+    {"   module       foo   (    )   ;     endmodule\n",
+     "module foo ();\n"
+     "endmodule\n"},
+    {"   module       foo   (  .x (  x) );     endmodule\n",
+     "module foo (\n"
+     "    .x(x)\n"
+     ");\n"
+     "endmodule\n"},
+    {"   module       foo   (  .x (  x)  \n,\n . y "
+     "  ( \ny) );     endmodule\n",
+     "module foo (\n"
+     "    .x(x),\n"
+     "    .y(y)\n"
+     ");\n"
+     "endmodule\n"},
+
+    // module instantiation test cases
+    {"  module foo   ; bar bq();endmodule\n",
+     "module foo;\n"
+     "  bar bq ();\n"  // single instance
+     "endmodule\n"},
+    {"  module foo   ; bar bq(), bq2(  );endmodule\n",
+     "module foo;\n"
+     "  bar bq (), bq2 ();\n"  // multiple instances, still fitting on one line
+     "endmodule\n"},
+    {"module foo; bar #(.N(N)) bq (.bus(bus));endmodule\n",
+     // instance parameter and port fits on line
+     "module foo;\n"
+     "  bar #(.N(N)) bq (.bus(bus));\n"
+     "endmodule\n"},
+    {"module foo; bar #(.N(N),.M(M)) bq ();endmodule\n",  // two named params
+     "module foo;\n"
+     "  bar #(\n"
+     "      .N(N),\n"
+     "      .M(M)\n"
+     "  ) bq ();\n"
+     "endmodule\n"},
+    {"module foo; bar #(//comment\n.N(N),.M(M)) bq ();endmodule\n",
+     "module foo;\n"
+     "  bar #(  //comment\n"  // EOL comment before first param
+     "      .N(N),\n"
+     "      .M(M)\n"
+     "  ) bq ();\n"
+     "endmodule\n"},
+    {"module foo; bar #(.N(N),//comment\n.M(M)) bq ();endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "      .N(N),  //comment\n"  // EOL comment after first param
+     "      .M(M)\n"
+     "  ) bq ();\n"
+     "endmodule\n"},
+    {"module foo; bar #(.N(N),.M(M)//comment\n) bq ();endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "      .N(N),\n"
+     "      .M(M)   //comment\n"  // EOL comment after last param
+     "  ) bq ();\n"
+     "endmodule\n"},
+    {"  module foo   ; bar bq(aa,bb,cc);endmodule\n",
+     "module foo;\n"
+     "  bar bq (\n"
+     "      aa,\n"
+     "      bb,\n"
+     "      cc\n"
+     "  );\n"  // multiple positional ports, one per line
+     "endmodule\n"},
+    {"  module foo   ; bar bq(aa,\n"
+     "`ifdef BB\n"
+     "bb,\n"
+     "`endif\n"
+     "cc);endmodule\n",
+     "module foo;\n"
+     "  bar bq (\n"
+     "      aa,\n"
+     "`ifdef BB\n"
+     "      bb,\n"  // keep same indentation as outside conditional
+     "`endif\n"
+     "      cc\n"
+     "  );\n"  // multiple positional ports, one per line
+     "endmodule\n"},
+    {"  module foo   ; bar bq(.aa,.bb);endmodule\n",
+     "module foo;\n"
+     "  bar bq (\n"
+     "      .aa,\n"
+     "      .bb\n"
+     "  );\n"  // multiple named ports, one per line
+     "endmodule\n"},
+    {"  module foo   ; bar bq(.aa(aa),.bb(bb));endmodule\n",
+     "module foo;\n"
+     "  bar bq (\n"
+     "      .aa(aa),\n"
+     "      .bb(bb)\n"
+     "  );\n"  // multiple named ports, one per line
+     "endmodule\n"},
+    {"  module foo   ; bar bq(.aa(aa),\n"
+     "`ifdef ZZ\n"
+     ".zz(  zz  ),\n"
+     "`else\n"
+     ".yy(  yy  ),\n"
+     "`endif\n"
+     ".bb(bb)\n"
+     ");endmodule\n",
+     "module foo;\n"
+     "  bar bq (\n"
+     "      .aa(aa),\n"
+     "`ifdef ZZ\n"
+     "      .zz(zz),\n"
+     "`else\n"
+     "      .yy(yy),\n"
+     "`endif\n"
+     "      .bb(bb)\n"
+     "  );\n"  // multiple named ports, one per line
+     "endmodule\n"},
+    {"  module foo   ; bar#(NNNNNNNN)"
+     "bq(.aa(aaaaaa),.bb(bbbbbb));endmodule\n",
+     "module foo;\n"
+     "  bar #(NNNNNNNN) bq (\n"
+     "      .aa(aaaaaa),\n"
+     "      .bb(bbbbbb)\n"
+     "  );\n"
+     "endmodule\n"},
+    {" module foo   ; barrrrrrr "
+     "bq(.aaaaaa(aaaaaa),.bbbbbb(bbbbbb));endmodule\n",
+     "module foo;\n"
+     "  barrrrrrr bq (\n"
+     "      .aaaaaa(aaaaaa),\n"
+     "      .bbbbbb(bbbbbb)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo; bar #(.NNNNN(NNNNN)) bq (.bussss(bussss));endmodule\n",
+     // instance parameter and port does not fit on line
+     "module foo;\n"
+     "  bar #(\n"
+     "      .NNNNN(NNNNN)\n"
+     "  ) bq (\n"
+     "      .bussss(bussss)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo; bar #(//\n.N(N)) bq (.bus(bus));endmodule\n",
+     "module foo;\n"
+     "  bar #(  //\n"  // would fit on one line, but forced to expand by //
+     "      .N(N)\n"
+     "  ) bq (\n"
+     "      .bus(bus)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo; bar #(\n"
+     "`ifdef MM\n"
+     ".M(M)\n"
+     "`else\n"
+     ".N(N)\n"
+     "`endif\n"
+     ") bq (.bus(bus));endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"
+     "`ifdef MM\n"
+     "      .M(M)\n"
+     "`else\n"
+     "      .N(N)\n"
+     "`endif\n"
+     "  ) bq (\n"
+     "      .bus(bus)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo; bar #(.N(N)//\n) bq (.bus(bus));endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"  // would fit on one line, but forced to expand by //
+     "      .N(N)  //\n"
+     "  ) bq (\n"
+     "      .bus(bus)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo; bar #(.N(N)) bq (//\n.bus(bus));endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"  // would fit on one line, but forced to expand by //
+     "      .N(N)\n"
+     "  ) bq (  //\n"
+     "      .bus(bus)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module foo; bar #(.N(N)) bq (.bus(bus)//\n);endmodule\n",
+     "module foo;\n"
+     "  bar #(\n"  // would fit on one line, but forced to expand by //
+     "      .N(N)\n"
+     "  ) bq (\n"
+     "      .bus(bus)  //\n"
+     "  );\n"
+     "endmodule\n"},
+    {" module foo   ; bar "
+     "bq(.aaa(aaa),.bbb(bbb),.ccc(ccc),.ddd(ddd));endmodule\n",
+     "module foo;\n"
+     "  bar bq (\n"
+     "      .aaa(aaa),\n"  // ports don't fit on one line, so expanded
+     "      .bbb(bbb),\n"
+     "      .ccc(ccc),\n"
+     "      .ddd(ddd)\n"
+     "  );\n"
+     "endmodule\n"},
+    {" module foo   ; bar "
+     "bq(.aa(aa),.bb(bb),.cc(cc),.dd(dd));endmodule\n",
+     "module foo;\n"
+     "  bar bq (\n"
+     "      .aa(aa),\n"  // one named port per line
+     "      .bb(bb),\n"
+     "      .cc(cc),\n"
+     "      .dd(dd)\n"
+     "  );\n"
+     "endmodule\n"},
+    {" module foo   ; bar "
+     "bq(.aa(aa),//\n.bb(bb),.cc(cc),.dd(dd));endmodule\n",
+     "module foo;\n"
+     "  bar bq (\n"
+     "      .aa(aa),  //\n"  // forced to expand by //
+     "      .bb(bb),\n"
+     "      .cc(cc),\n"
+     "      .dd(dd)\n"
+     "  );\n"
+     "endmodule\n"},
+    {" module foo   ; bar "
+     "bq(.aa(aa),.bb(bb),.cc(cc),.dd(dd)//\n);endmodule\n",
+     "module foo;\n"
+     "  bar bq (\n"
+     "      .aa(aa),\n"
+     "      .bb(bb),\n"
+     "      .cc(cc),\n"
+     "      .dd(dd)   //\n"  // forced to expand by //
+     "  );\n"
+     "endmodule\n"},
+    {// gate instantiation test
+     "module m;"
+     "and\tx0(a, \t\tb,c);"
+     "or\nx1(a,  \n b,    d);"
+     "endmodule\n",
+     "module m;\n"
+     "  and x0 (a, b, c);\n"
+     "  or x1 (a, b, d);\n"
+     "endmodule\n"},
+    {// ifdef inside port actuals
+     "module m;  foo bar   (\n"
+     "`ifdef   BAZ\n"
+     "`endif\n"
+     ")  ;endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "`ifdef BAZ\n"
+     "`endif\n"
+     "  );\n"
+     "endmodule\n"},
+    {// ifdef inside port actuals after a port connection
+     "module m;  foo bar   ( .a (a) ,\n"
+     "`ifdef   BAZ\n"
+     "`endif\n"
+     ")  ;endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .a(a),\n"
+     "`ifdef BAZ\n"
+     "`endif\n"
+     "  );\n"
+     "endmodule\n"},
+    {// ifdef inside port actuals before a port connection
+     "module m;  foo bar   (\n"
+     "`ifdef   BAZ\n"
+     "`endif\n"
+     ". b(b) )  ;endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "`ifdef BAZ\n"
+     "`endif\n"
+     "      .b(b)\n"
+     "  );\n"
+     "endmodule\n"},
+    {// ifdef-conditional port connection
+     "module m;  foo bar   (\n"
+     "`ifdef   BAZ\n"
+     ". c (\tc) \n"
+     "`endif\n"
+     " )  ;endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "`ifdef BAZ\n"
+     "      .c(c)\n"
+     "`endif\n"
+     "  );\n"
+     "endmodule\n"},
+    {// ifndef-else-conditional port connection
+     "module m;  foo bar   (\n"
+     "`ifndef   BAZ\n"
+     ". c (\tc) \n"
+     "  `else\n"
+     " . d(d\t)\n"
+     "  `endif\n"
+     " )  ;endmodule\n",
+     "module m;\n"
+     "  foo bar (\n"
+     "`ifndef BAZ\n"
+     "      .c(c)\n"
+     "`else\n"
+     "      .d(d)\n"
+     "`endif\n"
+     "  );\n"
+     "endmodule\n"},
+
+    {// comment following a delay in next line
+     "module t;\n"
+     "reg x;\n"
+     "initial begin\n"
+     "#20\n"
+     "//comment\n"
+     "x = 1;\n"
+     "x = 2;\n"
+     "end\n"
+     "endmodule\n",
+     "module t;\n"
+     "  reg x;\n"
+     "  initial begin\n"
+     "    #20\n"
+     "    //comment\n"
+     "    x = 1;\n"
+     "    x = 2;\n"
+     "  end\n"
+     "endmodule\n"},
+    {// comment following a delay in the same line
+     "module t;\n"
+     "reg x;\n"
+     "initial begin\n"
+     "#20 //comment\n"
+     "x = 1;\n"
+     "x = 2;\n"
+     "end\n"
+     "endmodule\n",
+     "module t;\n"
+     "  reg x;\n"
+     "  initial begin\n"
+     "    #20  //comment\n"
+     "    x = 1;\n"
+     "    x = 2;\n"
+     "  end\n"
+     "endmodule\n"},
+    // Macro calls inside [...]
+    {"module foo;\nlogic [`BAR(1)\n+2] foo;\nendmodule",
+     "module foo;\n"
+     "  logic [`BAR(1)\n"
+     "+2] foo;\n"
+     "endmodule\n"},
+    {"module foo;\nlogic [`BAR(1)+2] foo;\nendmodule",
+     "module foo;\n"
+     "  logic [`BAR(1)+2] foo;\n"
+     "endmodule\n"},
+    {"module foo ();\n  function bar();\n    "
+     "logic [12:34] data[`AAAAAAAAAAAAAAAAAAAAAAAA(1) : "
+     "`BBBBBBBBBBBBBBBBBBBBBBBB(2) + 3];\n  "
+     "endfunction\nendmodule",
+     "module foo ();\n"
+     "  function bar();\n"
+     "    logic [12:34] data[\n"
+     "    `AAAAAAAAAAAAAAAAAAAAAAAA(1) :\n"
+     "    `BBBBBBBBBBBBBBBBBBBBBBBB(2) + 3];\n"
+     "  endfunction\n"
+     "endmodule\n"},
+    {
+        // test that alternate top-syntax mode works
+        "// verilog_syntax: parse-as-module-body\n"
+        "`define           FOO\n",
+        "// verilog_syntax: parse-as-module-body\n"
+        "`define FOO\n",
+    },
+    {
+        // test alternate parsing mode in macro expansion
+        "class foo;\n"
+        "`MY_MACRO(\n"
+        " // verilog_syntax: parse-as-statements\n"
+        " // EOL comment\n"
+        " int count;\n"
+        " if(cfg.enable) begin\n"
+        " count = 1;\n"
+        " end,\n"
+        " utils_pkg::decrement())\n"
+        "endclass\n",
+        "class foo;\n"
+        "  `MY_MACRO(\n"
+        "      // verilog_syntax: parse-as-statements\n"
+        "      // EOL comment\n"
+        "      int count;\n"
+        "      if (cfg.enable) begin\n"
+        "        count = 1;\n"
+        "      end, utils_pkg::decrement())\n"
+        "endclass\n",
+    },
+
+    // tests top-level data declarations
+    {"a;",  // implicit type
+     "a;\n"},
+    {"a\tb;",  // explicit type
+     "a b;\n"},
+    {"a;b;",
+     "a;\n"
+     "b;\n"},
+    {"a ,b;",  // implicit type
+     "a, b;\n"},
+    /* TODO(b/149591599): implicit type data declarations in module body
+    {"module\tm ;a ;endmodule",
+     "module m;\n"
+     "  a;\n"
+     "endmodule\n"},
+    */
+    {"package\tp ;a ;endpackage",  // implicit type
+     "package p;\n"
+     "  a;\n"
+     "endpackage\n"},
+    {"package\tp ;a ,b ;endpackage",  // implicit type
+     "package p;\n"
+     "  a, b;\n"
+     "endpackage\n"},
+    {"package\tp ;a ;b ;endpackage",  // implicit type
+     "package p;\n"
+     "  a;\n"
+     "  b;\n"
+     "endpackage\n"},
+    /* TODO(b/149591627) : implicit type data declarations in class body
+    {"class\tc ;a ;endclass",
+     "class c;\n"
+     "  a;\n"
+     "endclass\n"},
+     */
+    {"function\tf ;a ;endfunction",  // implicit type
+     "function f;\n"
+     "  a;\n"
+     "endfunction\n"},
+    {"function\tf ;a   ;x ;endfunction",  // implicit type
+     "function f;\n"
+     "  a;\n"
+     "  x;\n"
+     "endfunction\n"},
+    /* TODO(b/149592527): multi-variable data declaration as block_item_decl
+     // same inside tasks
+    {"function\tf ;a  \t,x ;endfunction",  // implicit type
+     "function f;\n"
+     "  a, x;\n"
+     "endfunction\n"},
+     */
+    {"task\tt ;a ;endtask",  // implicit type
+     "task t;\n"
+     "  a;\n"
+     "endtask\n"},
+    {"task\tt ;a   ;x ;endtask",  // implicit type
+     "task t;\n"
+     "  a;\n"
+     "  x;\n"
+     "endtask\n"},
+
+    {// tests bind declaration
+     "bind   foo   bar baz  ( . clk ( clk  ) ) ;",
+     "bind foo bar baz (.clk(clk));\n"},
+    {// tests bind declaration, with type params
+     "bind   foo   bar# ( . W ( W ) ) baz  ( . clk ( clk  ) ) ;",
+     "bind foo bar #(.W(W)) baz (.clk(clk));\n"},
+    {// tests bind declarations
+     "bind   foo   bar baz  ( ) ;"
+     "bind goo  car  caz (   );",
+     "bind foo bar baz ();\n"
+     "bind goo car caz ();\n"},
+
+    {"bind blah foo #( .MaxCount(MaxCount), .MaxDelta(MaxDelta)) bar ("
+     "    .clk(clk), .rst(rst), .value(value) );",
+     "bind blah foo #(\n"
+     "    .MaxCount(MaxCount),\n"
+     "    .MaxDelta(MaxDelta)\n"
+     ") bar (\n"
+     "    .clk  (clk),\n"
+     "    .rst  (rst),\n"
+     "    .value(value)\n"
+     ");\n"},
+    {"bind foo bar baz(\\\n"
+     "`undef d\\\n"
+     "`undef d);",
+     "bind foo bar baz (\\\n"
+     "    `undef d\\\n"
+     "    `undef d\n"
+     ");\n"},
+    {
+        "bind expaaaaaaaaaaand_meeee looooooooong_name# ("
+        ".W(W_CONST), .H(H_CONST), .D(D_CONST)  )"
+        "instaaance_name (.in(iiiiiiiin), .out(ooooooout), .clk(ccccccclk));",
+        "bind expaaaaaaaaaaand_meeee\n"
+        "    looooooooong_name #(\n"
+        "    .W(W_CONST),\n"
+        "    .H(H_CONST),\n"
+        "    .D(D_CONST)\n"
+        ") instaaance_name (\n"
+        "    .in (iiiiiiiin),\n"
+        "    .out(ooooooout),\n"
+        "    .clk(ccccccclk)\n"
+        ");\n",
+    },
+
+    {
+        "bind expand_inst name# ("
+        ".W(W_CONST), .H(H_CONST), .D(D_CONST)  )"
+        "instaaance_name (.in(iiiiiiiin), .out(ooooooout), .clk(ccccccclk));",
+        "bind expand_inst name #(\n"
+        "    .W(W_CONST),\n"
+        "    .H(H_CONST),\n"
+        "    .D(D_CONST)\n"
+        ") instaaance_name (\n"
+        "    .in (iiiiiiiin),\n"
+        "    .out(ooooooout),\n"
+        "    .clk(ccccccclk)\n"
+        ");\n",
+    },
+
+    {
+        // tests import declaration
+        "import  foo_pkg :: bar ;",
+        "import foo_pkg::bar;\n",
+    },
+    {
+        // tests import declaration with wildcard
+        "import  foo_pkg :: * ;",
+        "import foo_pkg::*;\n",
+    },
+    {
+        // tests import declarations
+        "import  foo_pkg :: *\t;"
+        "import  goo_pkg\n:: thing ;",
+        "import foo_pkg::*;\n"
+        "import goo_pkg::thing;\n",
+    },
+    // preserve spaces inside [] dimensions, but limit spaces around ':' to one
+    // and adjust everything else
+    {"foo[W-1:0]a[0:K-1];",  // data declaration
+     "foo [W-1:0] a[0:K-1];\n"},
+    {"foo[W-1 : 0]a[0 : K-1];", "foo [W-1 : 0] a[0 : K-1];\n"},
+    {"foo[W  -  1 : 0 ]a [ 0  :  K  -  1] ;",
+     "foo [W  -  1 : 0] a[0 : K  -  1];\n"},
+    // remove spaces between [...] [...] in multi-dimension arrays
+    {"foo[K] [W]a;",  //
+     "foo [K][W] a;\n"},
+    {"foo b [K] [W] ;",  //
+     "foo b[K][W];\n"},
+    {"logic[K:1] [W:1]a;",  //
+     "logic [K:1][W:1] a;\n"},
+    {"logic b [K:1] [W:1] ;",  //
+     "logic b[K:1][W:1];\n"},
+    // spaces in bit slicing
+    {
+        // preserve 0 spaces
+        "always_ff @(posedge clk) begin "
+        "dummy  <=\tfoo  [  7:2  ] ; "
+        "end",
+        "always_ff @(posedge clk) begin\n"
+        "  dummy <= foo[7:2];\n"
+        "end\n",
+    },
+    {
+        // preserve 1 space
+        "always_ff @(posedge clk) begin "
+        "dummy  <=\tfoo  [  7 : 2  ] ; "
+        "end",
+        "always_ff @(posedge clk) begin\n"
+        "  dummy <= foo[7 : 2];\n"
+        "end\n",
+    },
+    {
+        // limit multiple spaces to 1
+        "always_ff @(posedge clk) begin "
+        "dummy  <=\tfoo  [  7  :  2  ] ; "
+        "end",
+        "always_ff @(posedge clk) begin\n"
+        "  dummy <= foo[7 : 2];\n"
+        "end\n",
+    },
+    {
+        "always_ff @(posedge clk) begin "
+        "dummy  <=\tfoo  [  7  : 2  ] ; "
+        "end",
+        "always_ff @(posedge clk) begin\n"
+        "  dummy <= foo[7 : 2];\n"
+        "end\n",
+    },
+    {
+        // keep value on the left when symmetrizing
+        "always_ff @(posedge clk) begin "
+        "dummy  <=\tfoo  [  7: 2  ] ; "
+        "end",
+        "always_ff @(posedge clk) begin\n"
+        "  dummy <= foo[7:2];\n"
+        "end\n",
+    },
+    {
+        "always_ff @(posedge clk) begin "
+        "dummy  <=\tfoo  [  7:  2  ] ; "
+        "end",
+        "always_ff @(posedge clk) begin\n"
+        "  dummy <= foo[7:2];\n"
+        "end\n",
+    },
+    {
+        "always_ff @(posedge clk) begin "
+        "dummy  <=\tfoo  [  7 :2  ] ; "
+        "end",
+        "always_ff @(posedge clk) begin\n"
+        "  dummy <= foo[7 : 2];\n"
+        "end\n",
+    },
+    {
+        "always_ff @(posedge clk) begin "
+        "dummy  <=\tfoo  [  7 :  2  ] ; "
+        "end",
+        "always_ff @(posedge clk) begin\n"
+        "  dummy <= foo[7 : 2];\n"
+        "end\n",
+    },
+    {
+        // use value on the left, but limit to 1 space
+        "always_ff @(posedge clk) begin "
+        "dummy  <=\tfoo  [  7  :2  ] ; "
+        "end",
+        "always_ff @(posedge clk) begin\n"
+        "  dummy <= foo[7 : 2];\n"
+        "end\n",
+    },
+
+    // task test cases
+    {"task t ;endtask:t",  //
+     "task t;\n"
+     "endtask : t\n"},
+    {"task t ;#   10 ;# 5ns ; # 0.1 ; # 1step ;endtask",
+     "task t;\n"
+     "  #10;\n"  // no space in delay expression
+     "  #5ns;\n"
+     "  #0.1;\n"
+     "  #1step;\n"
+     "endtask\n"},
+    {"task t\n;a<=b ;c<=d ;endtask\n",
+     "task t;\n"
+     "  a <= b;\n"
+     "  c <= d;\n"
+     "endtask\n"},
+    {"class c;   virtual protected task\tt  ( foo bar);"
+     "a.a<=b.b;\t\tc.c\n<=   d.d; endtask   endclass",
+     "class c;\n"
+     "  virtual protected task t(foo bar);\n"
+     "    a.a <= b.b;\n"
+     "    c.c <= d.d;\n"
+     "  endtask\n"
+     "endclass\n"},
+    {"task t;\n// statement comment\nendtask\n",
+     "task t;\n"
+     "  // statement comment\n"  // indented
+     "endtask\n"},
+    {"task t( );\n// statement comment\nendtask\n",
+     "task t();\n"
+     "  // statement comment\n"  // indented
+     "endtask\n"},
+    {"task t( input x  );\n"
+     "// statement comment\n"
+     "s();\n"
+     "// statement comment\n"
+     "endtask\n",
+     "task t(input x);\n"
+     "  // statement comment\n"  // indented
+     "  s();\n"
+     "  // statement comment\n"  // indented
+     "endtask\n"},
+    {"task fj;fork join fork join\tendtask",
+     "task fj;\n"
+     "  fork\n"
+     "  join\n"
+     "  fork\n"
+     "  join\n"
+     "endtask\n"},
+    {"task fj;fork join_any fork join_any\tendtask",
+     "task fj;\n"
+     "  fork\n"
+     "  join_any\n"
+     "  fork\n"
+     "  join_any\n"
+     "endtask\n"},
+    {"task fj;fork join_none fork join_none\tendtask",
+     "task fj;\n"
+     "  fork\n"
+     "  join_none\n"
+     "  fork\n"
+     "  join_none\n"
+     "endtask\n"},
+    {"task fj;fork\n"
+     "//c1\njoin\n"
+     "//c2\n"
+     "fork  \n"
+     "//c3\n"
+     "join\tendtask",
+     "task fj;\n"
+     "  fork\n"
+     "    //c1\n"
+     "  join\n"
+     "  //c2\n"
+     "  fork\n"
+     "    //c3\n"
+     "  join\n"
+     "endtask\n"},
+    {"task fj;\n"
+     "fork "
+     "begin "
+     "end "
+     "foo();"
+     "begin "
+     "end "
+     "join_any endtask",
+     "task fj;\n"
+     "  fork\n"
+     "    begin\n"
+     "    end\n"
+     "    foo();\n"
+     "    begin\n"
+     "    end\n"
+     "  join_any\n"
+     "endtask\n"},
+    {
+        // call and assertion statements
+        "task  t ;Fire() ;assert ( x);assert(y );endtask",
+        "task t;\n"
+        "  Fire();\n"
+        "  assert (x);\n"
+        "  assert (y);\n"
+        "endtask\n",
+    },
+    {
+        // assertion statements with body clause
+        "task  t ;Fire() ;assert ( x) fee ( );assert(y ) foo ( ) ;endtask",
+        "task t;\n"
+        "  Fire();\n"
+        "  assert (x) fee();\n"
+        "  assert (y) foo();\n"
+        "endtask\n",
+    },
+    {
+        // assertion statements with else clause
+        "task  t ;Fire() ;assert ( x) else  fee ( );"
+        "assert(y ) else  foo ( ) ;endtask",
+        "task t;\n"
+        "  Fire();\n"
+        "  assert (x)\n"
+        "  else fee();\n"
+        "  assert (y)\n"
+        "  else foo();\n"
+        "endtask\n",
+    },
+    {
+        // assertion statements with else clause
+        "task  t ;Fire() ;assert ( x) fa(); else  fee ( );"
+        "assert(y ) fi(); else  foo ( ) ;endtask",
+        "task t;\n"
+        "  Fire();\n"
+        "  assert (x) fa();\n"
+        "  else fee();\n"
+        "  assert (y) fi();\n"
+        "  else foo();\n"
+        "endtask\n",
+    },
+    {
+        // assume statements
+        "task  t ;Fire() ;assume ( x);assume(y );endtask",
+        "task t;\n"
+        "  Fire();\n"
+        "  assume (x);\n"
+        "  assume (y);\n"
+        "endtask\n",
+    },
+    {
+        // cover statements
+        "task  t ;Fire() ;cover ( x);cover(y );endtask",
+        "task t;\n"
+        "  Fire();\n"
+        "  cover (x);\n"
+        "  cover (y);\n"
+        "endtask\n",
+    },
+    {
+        // cover statements, with action
+        "task  t ;Fire() ;cover ( x)g( );cover(y ) h();endtask",
+        "task t;\n"
+        "  Fire();\n"
+        "  cover (x) g();\n"
+        "  cover (y) h();\n"
+        "endtask\n",
+    },
+    {
+        // cover statements, with action block
+        "task  t ;Fire() ;cover ( x) begin g( ); end "
+        "cover(y ) begin h(); end endtask",
+        "task t;\n"
+        "  Fire();\n"
+        "  cover (x) begin\n"
+        "    g();\n"
+        "  end\n"
+        "  cover (y) begin\n"
+        "    h();\n"
+        "  end\n"
+        "endtask\n",
+    },
+    {// shuffle calls
+     "task t; foo. shuffle  ( );bar .shuffle( ); endtask",
+     "task t;\n"
+     "  foo.shuffle();\n"
+     "  bar.shuffle();\n"
+     "endtask\n"},
+    {// wait statements (null)
+     "task t; wait  (a==b);wait(c<d); endtask",
+     "task t;\n"
+     "  wait (a == b);\n"
+     "  wait (c < d);\n"
+     "endtask\n"},
+    {// wait statements, single action statement
+     "task t; wait  (a==b) p();wait(c<d) q(); endtask",
+     "task t;\n"
+     "  wait (a == b) p();\n"
+     "  wait (c < d) q();\n"
+     "endtask\n"},
+    {// wait statements, block action statement
+     "task t; wait  (a==b) begin p(); end "
+     "wait(c<d) begin q(); end endtask",
+     "task t;\n"
+     "  wait (a == b) begin\n"
+     "    p();\n"
+     "  end\n"
+     "  wait (c < d) begin\n"
+     "    q();\n"
+     "  end\n"
+     "endtask\n"},
+    {// wait fork statements
+     "task t ; wait\tfork;wait   fork ;endtask",
+     "task t;\n"
+     "  wait fork;\n"
+     "  wait fork;\n"
+     "endtask\n"},
+    {// labeled single statements (prefix-style)
+     "task t;l1:x<=y ;endtask",
+     "task t;\n"
+     "  l1 : x <= y;\n"
+     "endtask\n"},
+    {// labeled block statements (prefix-style)
+     "task t;l1:begin end:l1 endtask",
+     "task t;\n"
+     "  l1 : begin\n"
+     "  end : l1\n"
+     "endtask\n"},
+    {// labeled seq block statements
+     "task t;begin:l1 end:l1 endtask",
+     "task t;\n"
+     "  begin : l1\n"
+     "  end : l1\n"
+     "endtask\n"},
+    {// labeled par block statements
+     "task t;fork:l1 join:l1 endtask",
+     "task t;\n"
+     "  fork : l1\n"
+     "  join : l1\n"
+     "endtask\n"},
+    {// task with disable statements
+     "task  t ;fork\tjoin\tdisable\tfork;endtask",
+     "task t;\n"
+     "  fork\n"
+     "  join\n"
+     "  disable fork;\n"
+     "endtask\n"},
+    {"task  t ;fork\tjoin_any\tdisable\tfork  ;endtask",
+     "task t;\n"
+     "  fork\n"
+     "  join_any\n"
+     "  disable fork;\n"
+     "endtask\n"},
+    {"task  t ;disable\tbean_counter  ;endtask",
+     "task t;\n"
+     "  disable bean_counter;\n"
+     "endtask\n"},
+    {
+        // task with if-statement
+        "task t;"
+        "if (r == t)"
+        "a.b(c);"
+        "endtask",
+        "task t;\n"
+        "  if (r == t) a.b(c);\n"
+        "endtask\n",
+    },
+    {
+        // task with system call inside if header
+        "task t;"
+        "if (!$cast(ssssssssssssssss,vvvvvvvvvv,gggggggg))begin end endtask:t",
+        "task t;\n"
+        "  if (!$cast(\n"
+        "          ssssssssssssssss,\n"
+        "          vvvvvvvvvv,\n"
+        "          gggggggg\n"
+        "      )) begin\n"
+        "  end\n"
+        "endtask : t\n",
+    },
+    {
+        // task with nested subtask call and arguments passed by name
+        "task t;"
+        "if (!$cast(ssssssssssssssss, vvvvvvvvvv.gggggggg("
+        ".ppppppp(ppppppp),"
+        ".yyyyy(\"xxxxxxxxxxxxx\")"
+        "))) begin "
+        "end "
+        "endtask : t",
+        "task t;\n"
+        "  if (!$cast(\n"
+        "          ssssssssssssssss,\n"
+        "          vvvvvvvvvv.gggggggg(\n"
+        "              .ppppppp(ppppppp),\n"
+        "              .yyyyy(\"xxxxxxxxxxxxx\")\n"
+        "          )\n"
+        "      )) begin\n"
+        "  end\n"
+        "endtask : t\n",
+    },
+
+    {
+        // assert property statements
+        "task  t ;assert  property( x);assert\tproperty(y );endtask",
+        "task t;\n"
+        "  assert property (x);\n"
+        "  assert property (y);\n"
+        "endtask\n",
+    },
+    {
+        // assert property statements, with action
+        "task  t ;assert  property( x) j();assert\tproperty(y )k( );endtask",
+        "task t;\n"
+        "  assert property (x) j();\n"
+        "  assert property (y) k();\n"
+        "endtask\n",
+    },
+    {
+        // assert property statements, with action block
+        "task  t ;assert  property( x) begin j();end "
+        " assert\tproperty(y )begin\tk( );  end endtask",
+        "task t;\n"
+        "  assert property (x) begin\n"
+        "    j();\n"
+        "  end\n"
+        "  assert property (y) begin\n"
+        "    k();\n"
+        "  end\n"
+        "endtask\n",
+    },
+    {
+        // assert property statements, else with null
+        "task  t ;assert  property( x) else;assert\tproperty(y )else;endtask",
+        "task t;\n"
+        "  assert property (x)\n"
+        "  else;\n"
+        "  assert property (y)\n"
+        "  else;\n"
+        "endtask\n",
+    },
+    {
+        // assert property statements, else with actions
+        "task  t ;assert  property( x) f(); else p(); "
+        "\tassert\tproperty(y ) g();else  q( );endtask",
+        "task t;\n"
+        "  assert property (x) f();\n"
+        "  else p();\n"
+        "  assert property (y) g();\n"
+        "  else q();\n"
+        "endtask\n",
+    },
+    {
+        // assert property statement, with action block, else statement
+        "task  t ;assert  property( x) begin j();end  else\tk( );  endtask",
+        "task t;\n"
+        "  assert property (x) begin\n"
+        "    j();\n"
+        "  end else k();\n"
+        "endtask\n",
+    },
+    {
+        // assert property statement, with action statement, else block
+        "task  t ;assert  property( x) j();  else  begin\tk( );end  endtask",
+        "task t;\n"
+        "  assert property (x) j();\n"
+        "  else begin\n"
+        "    k();\n"
+        "  end\n"
+        "endtask\n",
+    },
+    {
+        // assert property statement, with action block, else block
+        "task  t ;assert  property( x)begin j();end  "
+        "else  begin\tk( );end  endtask",
+        "task t;\n"
+        "  assert property (x) begin\n"
+        "    j();\n"
+        "  end else begin\n"
+        "    k();\n"
+        "  end\n"
+        "endtask\n",
+    },
+
+    {
+        // assume property statements
+        "task  t ;assume  property( x);assume\tproperty(y );endtask",
+        "task t;\n"
+        "  assume property (x);\n"
+        "  assume property (y);\n"
+        "endtask\n",
+    },
+    {
+        // assume property statements, with action
+        "task  t ;assume  property( x) j();assume\tproperty(y )k( );endtask",
+        "task t;\n"
+        "  assume property (x) j();\n"
+        "  assume property (y) k();\n"
+        "endtask\n",
+    },
+    {
+        // assume property statements, with action block
+        "task  t ;assume  property( x) begin j();end "
+        " assume\tproperty(y )begin\tk( );  end endtask",
+        "task t;\n"
+        "  assume property (x) begin\n"
+        "    j();\n"
+        "  end\n"
+        "  assume property (y) begin\n"
+        "    k();\n"
+        "  end\n"
+        "endtask\n",
+    },
+    {
+        // assume property statements, else with null
+        "task  t ;assume  property( x) else;assume\tproperty(y )else;endtask",
+        "task t;\n"
+        "  assume property (x)\n"
+        "  else;\n"
+        "  assume property (y)\n"
+        "  else;\n"
+        "endtask\n",
+    },
+    {
+        // assume property statements, else with actions
+        "task  t ;assume  property( x) f(); else p(); "
+        "\tassume\tproperty(y ) g();else  q( );endtask",
+        "task t;\n"
+        "  assume property (x) f();\n"
+        "  else p();\n"
+        "  assume property (y) g();\n"
+        "  else q();\n"
+        "endtask\n",
+    },
+    {
+        // assume property statement, with action block, else statement
+        "task  t ;assume  property( x) begin j();end  else\tk( );  endtask",
+        "task t;\n"
+        "  assume property (x) begin\n"
+        "    j();\n"
+        "  end else k();\n"
+        "endtask\n",
+    },
+    {
+        // assume property statement, with action statement, else block
+        "task  t ;assume  property( x) j();  else  begin\tk( );end  endtask",
+        "task t;\n"
+        "  assume property (x) j();\n"
+        "  else begin\n"
+        "    k();\n"
+        "  end\n"
+        "endtask\n",
+    },
+    {
+        // assume property statement, with action block, else block
+        "task  t ;assume  property( x)begin j();end  "
+        "else  begin\tk( );end  endtask",
+        "task t;\n"
+        "  assume property (x) begin\n"
+        "    j();\n"
+        "  end else begin\n"
+        "    k();\n"
+        "  end\n"
+        "endtask\n",
+    },
+
+    {
+        // expect property statements
+        "task  t ;expect  ( x);expect\t(y );endtask",
+        "task t;\n"
+        "  expect (x);\n"
+        "  expect (y);\n"
+        "endtask\n",
+    },
+    {
+        // expect property statements, with action
+        "task  t ;expect  ( x) j();expect\t(y )k( );endtask",
+        "task t;\n"
+        "  expect (x) j();\n"
+        "  expect (y) k();\n"
+        "endtask\n",
+    },
+    {
+        // expect property statements, with action block
+        "task  t ;expect  ( x) begin j();end "
+        " expect\t(y )begin\tk( );  end endtask",
+        "task t;\n"
+        "  expect (x) begin\n"
+        "    j();\n"
+        "  end\n"
+        "  expect (y) begin\n"
+        "    k();\n"
+        "  end\n"
+        "endtask\n",
+    },
+    {
+        // expect property statements, else with null
+        "task  t ;expect  ( x) else;expect\t(y )else;endtask",
+        "task t;\n"
+        "  expect (x)\n"
+        "  else;\n"
+        "  expect (y)\n"
+        "  else;\n"
+        "endtask\n",
+    },
+    {
+        // expect property statements, else with actions
+        "task  t ;expect  ( x) f(); else p(); "
+        "\texpect\t(y ) g();else  q( );endtask",
+        "task t;\n"
+        "  expect (x) f();\n"
+        "  else p();\n"
+        "  expect (y) g();\n"
+        "  else q();\n"
+        "endtask\n",
+    },
+    {
+        // expect property statement, with action block, else statement
+        "task  t ;expect  ( x) begin j();end  else\tk( );  endtask",
+        "task t;\n"
+        "  expect (x) begin\n"
+        "    j();\n"
+        "  end else k();\n"
+        "endtask\n",
+    },
+    {
+        // expect property statement, with action statement, else block
+        "task  t ;expect  ( x) j();  else  begin\tk( );end  endtask",
+        "task t;\n"
+        "  expect (x) j();\n"
+        "  else begin\n"
+        "    k();\n"
+        "  end\n"
+        "endtask\n",
+    },
+    {
+        // expect property statement, with action block, else block
+        "task  t ;expect  ( x)begin j();end  "
+        "else  begin\tk( );end  endtask",
+        "task t;\n"
+        "  expect (x) begin\n"
+        "    j();\n"
+        "  end else begin\n"
+        "    k();\n"
+        "  end\n"
+        "endtask\n",
+    },
+
+    {
+        // cover property statements
+        "task  t ;cover  property( x);cover\tproperty(y );endtask",
+        "task t;\n"
+        "  cover property (x);\n"
+        "  cover property (y);\n"
+        "endtask\n",
+    },
+    {
+        // cover property statements, with action
+        "task  t ;cover  property( x) j();cover\tproperty(y )k( );endtask",
+        "task t;\n"
+        "  cover property (x) j();\n"
+        "  cover property (y) k();\n"
+        "endtask\n",
+    },
+    {
+        // cover property statements, with action block
+        "task  t ;cover  property( x) begin j();end "
+        " cover\tproperty(y )begin\tk( );  end endtask",
+        "task t;\n"
+        "  cover property (x) begin\n"
+        "    j();\n"
+        "  end\n"
+        "  cover property (y) begin\n"
+        "    k();\n"
+        "  end\n"
+        "endtask\n",
+    },
+
+    {
+        // cover sequence statements
+        "task  t ;cover  sequence( x);cover\tsequence(y );endtask",
+        "task t;\n"
+        "  cover sequence (x);\n"
+        "  cover sequence (y);\n"
+        "endtask\n",
+    },
+    {
+        // cover sequence statements, with action
+        "task  t ;cover  sequence( x) j();cover\tsequence(y )k( );endtask",
+        "task t;\n"
+        "  cover sequence (x) j();\n"
+        "  cover sequence (y) k();\n"
+        "endtask\n",
+    },
+    {
+        // cover sequence statements, with action block
+        "task  t ;cover  sequence( x) begin j();end "
+        " cover\tsequence(y )begin\tk( );  end endtask",
+        "task t;\n"
+        "  cover sequence (x) begin\n"
+        "    j();\n"
+        "  end\n"
+        "  cover sequence (y) begin\n"
+        "    k();\n"
+        "  end\n"
+        "endtask\n",
+    },
+
+    {// module with disable statements
+     "module m;always begin :block disable m.block; end endmodule",
+     "module m;\n"
+     "  always begin : block\n"
+     "    disable m.block;\n"
+     "  end\n"
+     "endmodule\n"},
+    {"module m;always begin disable m.block; end endmodule",
+     "module m;\n"
+     "  always begin\n"
+     "    disable m.block;\n"
+     "  end\n"
+     "endmodule\n"},
+
+    // property test cases
+    {"module mp ;property p1 ; a|->b;endproperty endmodule",
+     "module mp;\n"
+     "  property p1;\n"
+     "    a |-> b;\n"
+     "  endproperty\n"
+     "endmodule\n"},
+    {"module mp ;property p1 ; a|->b;endproperty:p1 endmodule",
+     "module mp;\n"
+     "  property p1;\n"
+     "    a |-> b;\n"
+     "  endproperty : p1\n"  // with end label
+     "endmodule\n"},
+    {"module mp ;property p1 ; a|->## 1  b;endproperty endmodule",
+     "module mp;\n"
+     "  property p1;\n"
+     "    a |-> ##1 b;\n"  // with delay
+     "  endproperty\n"
+     "endmodule\n"},
+    {"module mp ;property p1 ; a|->## [0: 1]  b;endproperty endmodule",
+     "module mp;\n"
+     "  property p1;\n"
+     "    a |-> ##[0:1] b;\n"  // prefer no spaces with delay range
+     "  endproperty\n"
+     "endmodule\n"},
+    {"module mp ;property p1 ; a|->## [0  : 1]  b;endproperty endmodule",
+     "module mp;\n"
+     "  property p1;\n"
+     "    a |-> ##[0 : 1] b;\n"  // limit to one space, symmetrize
+     "  endproperty\n"
+     "endmodule\n"},
+    {"module mp ;property p1 ; a## 1  b;endproperty endmodule",
+     "module mp;\n"
+     "  property p1;\n"
+     "    a ##1 b;\n"
+     "  endproperty\n"
+     "endmodule\n"},
+    {"module mp ;property p1 ; (a^c)## 1  b;endproperty endmodule",
+     "module mp;\n"
+     "  property p1;\n"
+     "    (a ^ c) ##1 b;\n"
+     "  endproperty\n"
+     "endmodule\n"},
+
+    // covergroup test cases
+    {// Minimal case
+     "covergroup c; endgroup\n",
+     "covergroup c;\n"
+     "endgroup\n"},
+    {// Minimal useful case
+     "covergroup c @ (posedge clk); coverpoint a; endgroup\n",
+     "covergroup c @(posedge clk);\n"
+     "  coverpoint a;\n"
+     "endgroup\n"},
+    {// Multiple coverpoints
+     "covergroup foo @(posedge clk); coverpoint a; coverpoint b; "
+     "coverpoint c; coverpoint d; endgroup\n",
+     "covergroup foo @(posedge clk);\n"
+     "  coverpoint a;\n"
+     "  coverpoint b;\n"
+     "  coverpoint c;\n"
+     "  coverpoint d;\n"
+     "endgroup\n"},
+    {// Multiple bins
+     "covergroup memory @ (posedge ce); address  :coverpoint addr {"
+     "bins low={0,127}; bins high={128,255};} endgroup\n",
+     "covergroup memory @(posedge ce);\n"
+     "  address: coverpoint addr {\n"
+     "    bins low = {0, 127};\n"
+     "    bins high = {128, 255};\n"
+     "  }\n"
+     "endgroup\n"},
+    {// Custom sample() function
+     "covergroup c with function sample(bit i); endgroup\n",
+     "covergroup c with function sample (\n"
+     "    bit i\n"  // test cases are wrapped at 40
+     ");\n"
+     "endgroup\n"},
+
+};
+
+TEST(FormatterEndToEndTest, FunctionTaskFormatterTestCases) {
+  RunFormatterTestCases40(kFunctionTaskFormatterTestCases);
+}
+
+}  // namespace
+}  // namespace formatter
+}  // namespace verilog
diff --git a/verible/verilog/formatting/formatter_issue_regression_test.cc b/verible/verilog/formatting/formatter_issue_regression_test.cc
new file mode 100644
index 0000000..8f1fcef
--- /dev/null
+++ b/verible/verilog/formatting/formatter_issue_regression_test.cc
@@ -0,0 +1,319 @@
+// Copyright 2017-2026 The Verible Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Test cases in this file should be *insensitive* to wrapping penalties.
+// Penalty-sensitive tests belong in formatter-tuning_test.cc.
+
+#include <sstream>
+#include <string_view>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "verible/common/util/logging.h"
+#include "verible/verilog/formatting/format-style.h"
+#include "verible/verilog/formatting/formatter-test-utils.h"
+#include "verible/verilog/formatting/formatter.h"
+
+namespace verilog {
+namespace formatter {
+namespace {
+
+// Regression for https://github.com/chipsalliance/verible/issues/2547:
+// A localparam initialized to a sum of long macros must converge: infix `+`
+// stays with the following operand so re-format does not oscillate between
+// `+\n`MACRO` and `+ `MACRO`.
+TEST(FormatterEndToEndTest, LongMacroSumLocalparamConverges) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {"module m;\n"
+       "  localparam N =\n"
+       "      `MACRO_GEN3_SCRAMBLE_LFSR_REGOUT\n"
+       "      + `MACRO_GEN3_SCRAMBLE_REGIN\n"
+       "      + `MACRO_GEN3_SCRAMBLE_REGOUT\n"
+       "      ;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam N =\n"
+       "  `MACRO_GEN3_SCRAMBLE_LFSR_REGOUT\n"
+       "  + `MACRO_GEN3_SCRAMBLE_REGIN\n"
+       "  + `MACRO_GEN3_SCRAMBLE_REGOUT;\n"
+       "endmodule\n"},
+      // Already in pass-1 form must stay stable.
+      {"module m;\n"
+       "  localparam N =\n"
+       "  `MACRO_GEN3_SCRAMBLE_LFSR_REGOUT\n"
+       "  + `MACRO_GEN3_SCRAMBLE_REGIN\n"
+       "  + `MACRO_GEN3_SCRAMBLE_REGOUT;\n"
+       "endmodule\n",
+       "module m;\n"
+       "  localparam N =\n"
+       "  `MACRO_GEN3_SCRAMBLE_LFSR_REGOUT\n"
+       "  + `MACRO_GEN3_SCRAMBLE_REGIN\n"
+       "  + `MACRO_GEN3_SCRAMBLE_REGOUT;\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;  // default column_limit (100)
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Regression for https://github.com/chipsalliance/verible/issues/2544:
+// Wrapping a $bits(...)'(...) cast may leave `MACRO at EOL, reclassifying
+// MacroIdentifier as MacroIdItem. FormatEquivalent must accept that, and
+// formatting must still pass verification.
+TEST(FormatterEndToEndTest, MacroBeforeCloseParenFormatEquivalent) {
+  static constexpr std::string_view kInput =
+      "module m;\n"
+      "  assign result_value = $bits(result_value)'( "
+      "compare_bytes(input_data[DATA_WIDTH_INT-1:0], "
+      "input_datak[STROBE_WIDTH_INT-1:0], `TOKEN_BYTE) );\n"
+      "endmodule\n";
+  FormatStyle style;
+  std::ostringstream stream;
+  const auto status = FormatVerilog(kInput, "<filename>", style, stream);
+  EXPECT_OK(status) << status.message();
+  EXPECT_THAT(stream.str(), testing::HasSubstr("`TOKEN_BYTE"));
+}
+
+// Regression for https://github.com/chipsalliance/verible/issues/2542:
+// Continuation EOL comments after a wrapped assign must keep a stable column
+// across re-format (convergence).
+TEST(FormatterEndToEndTest, ContinuationCommentAfterWrappedAssignConverges) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// Comments originally column-aligned after a wrapped assign
+       "module m;\n"
+       "  assign status_ur = !(status_sc || status_ca ||\n"
+       "    status_crs);      // Completions with a Reserved Completion\n"
+       "                      // Status value are treated as UR\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign status_ur =\n"
+       "      !(status_sc || status_ca || status_crs);  // Completions with a "
+       "Reserved Completion\n"
+       "                                                // Status value are "
+       "treated as UR\n"
+       "endmodule\n"},
+      {// Previously mis-aligned continuation is not treated as a continuation
+       // (column delta > 1) and must still converge
+       "module m;\n"
+       "  assign status_ur = !(status_sc || status_ca ||\n"
+       "    status_crs);      // Completions with a Reserved Completion\n"
+       "                                                                       "
+       "// Status value are treated as UR\n"
+       "endmodule\n",
+       "module m;\n"
+       "  assign status_ur =\n"
+       "      !(status_sc || status_ca || status_crs);  // Completions with a "
+       "Reserved Completion\n"
+       "  // Status value are treated as UR\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;  // default column_limit (100)
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Regression for https://github.com/chipsalliance/verible/issues/2540:
+// Trailing EOL comment after `end` before `else if` must not change whether
+// the else-if assignment stays on one line across re-format (convergence).
+TEST(FormatterEndToEndTest, EndElseIfWithEOLCommentConverges) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// Comment on its own line between end and else if
+       "module m;\n"
+       "  always_comb begin\n"
+       "    case (state)\n"
+       "      STATE_A: begin\n"
+       "        if (cond_aaaa) next_state_value = STATE_B;\n"
+       "        else if (cond_bbbb) begin\n"
+       "          next_state_value = STATE_B;\n"
+       "        end\n"
+       "        // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
+       "        else if (cond_cccc) next_state_value = STATE_C;\n"
+       "      end\n"
+       "    endcase\n"
+       "  end\n"
+       "endmodule\n",
+       "module m;\n"
+       "  always_comb begin\n"
+       "    case (state)\n"
+       "      STATE_A: begin\n"
+       "        if (cond_aaaa) next_state_value = STATE_B;\n"
+       "        else if (cond_bbbb) begin\n"
+       "          next_state_value = STATE_B;\n"
+       "        end  // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
+       "        else if (cond_cccc) next_state_value = STATE_C;\n"
+       "      end\n"
+       "    endcase\n"
+       "  end\n"
+       "endmodule\n"},
+      {// Same construct with comment already on the end line
+       "module m;\n"
+       "  always_comb begin\n"
+       "    case (state)\n"
+       "      STATE_A: begin\n"
+       "        if (cond_aaaa) next_state_value = STATE_B;\n"
+       "        else if (cond_bbbb) begin\n"
+       "          next_state_value = STATE_B;\n"
+       "        end  // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
+       "        else if (cond_cccc) next_state_value = STATE_C;\n"
+       "      end\n"
+       "    endcase\n"
+       "  end\n"
+       "endmodule\n",
+       "module m;\n"
+       "  always_comb begin\n"
+       "    case (state)\n"
+       "      STATE_A: begin\n"
+       "        if (cond_aaaa) next_state_value = STATE_B;\n"
+       "        else if (cond_bbbb) begin\n"
+       "          next_state_value = STATE_B;\n"
+       "        end  // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
+       "        else if (cond_cccc) next_state_value = STATE_C;\n"
+       "      end\n"
+       "    endcase\n"
+       "  end\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;  // default column_limit (100)
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Regression for https://github.com/chipsalliance/verible/issues/2008
+// (also https://github.com/chipsalliance/verible/issues/2474 and
+// https://github.com/chipsalliance/verible/issues/2063):
+// Non-ANSI "input wire signed" used to abort in the tree-unwrapper because
+// the CST visited "signed" before "wire", which is the reverse of source
+// order.
+TEST(FormatterEndToEndTest, NonAnsiWireSignedModulePortDoesNotAbort) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {// Original issue #2008 sample
+       "module uut( sig1 );\n"
+       "\n"
+       "input wire signed [15:0] sig1;\n"
+       "\n"
+       "endmodule\n",
+       "module uut (\n"
+       "    sig1\n"
+       ");\n"
+       "\n"
+       "  input wire signed [15:0] sig1;\n"
+       "\n"
+       "endmodule\n"},
+      {// Issue #2474 sample
+       "module myModule (\n"
+       "    myinput\n"
+       ");\n"
+       "input wire signed [7:0] myInput;\n"
+       "endmodule\n",
+       "module myModule (\n"
+       "    myinput\n"
+       ");\n"
+       "  input wire signed [7:0] myInput;\n"
+       "endmodule\n"},
+      {// Issue #2063 sample: signed wire with no packed dimensions
+       "module top(a);\n"
+       "    input wire signed a;\n"
+       "endmodule\n",
+       "module top (\n"
+       "    a\n"
+       ");\n"
+       "  input wire signed a;\n"
+       "endmodule\n"},
+      {// Same production with logic instead of wire
+       "module uut(sig1);\n"
+       "input logic signed [15:0] sig1;\n"
+       "endmodule\n",
+       "module uut (\n"
+       "    sig1\n"
+       ");\n"
+       "  input logic signed [15:0] sig1;\n"
+       "endmodule\n"},
+      {// output / inout net types
+       "module uut(sig1, sig2);\n"
+       "output wire signed [15:0] sig1;\n"
+       "inout wire signed [7:0] sig2;\n"
+       "endmodule\n",
+       "module uut (\n"
+       "    sig1,\n"
+       "    sig2\n"
+       ");\n"
+       "  output wire signed [15:0] sig1;\n"
+       "  inout wire signed [7:0] sig2;\n"
+       "endmodule\n"},
+      {// unsigned is the same production
+       "module uut(sig1);\n"
+       "input wire unsigned [15:0] sig1;\n"
+       "endmodule\n",
+       "module uut (\n"
+       "    sig1\n"
+       ");\n"
+       "  input wire unsigned [15:0] sig1;\n"
+       "endmodule\n"},
+      {// ANSI form already worked; keep as a regression
+       "module uut(input wire signed [15:0] sig1);\n"
+       "endmodule\n",
+       "module uut (\n"
+       "    input wire signed [15:0] sig1\n"
+       ");\n"
+       "endmodule\n"},
+      {// Non-ANSI without signed still works
+       "module uut(sig1);\n"
+       "input wire [15:0] sig1;\n"
+       "endmodule\n",
+       "module uut (\n"
+       "    sig1\n"
+       ");\n"
+       "  input wire [15:0] sig1;\n"
+       "endmodule\n"},
+      {// Non-ANSI signed without net type still works
+       "module uut(sig1);\n"
+       "input signed [15:0] sig1;\n"
+       "endmodule\n",
+       "module uut (\n"
+       "    sig1\n"
+       ");\n"
+       "  input signed [15:0] sig1;\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;  // default column_limit (100)
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+}  // namespace
+}  // namespace formatter
+}  // namespace verilog
diff --git a/verible/verilog/formatting/formatter_macro_test.cc b/verible/verilog/formatting/formatter_macro_test.cc
new file mode 100644
index 0000000..25f4b90
--- /dev/null
+++ b/verible/verilog/formatting/formatter_macro_test.cc
@@ -0,0 +1,555 @@
+// Copyright 2017-2026 The Verible Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Test cases in this file should be *insensitive* to wrapping penalties.
+// Penalty-sensitive tests belong in formatter-tuning_test.cc.
+
+#include "gtest/gtest.h"
+#include "verible/verilog/formatting/formatter-test-utils.h"
+
+namespace verilog {
+namespace formatter {
+namespace {
+
+static constexpr FormatterTestCase kMacroFormatterTestCases[] = {
+    // preprocessor test cases
+    {"`include    \"path/to/file.vh\"\n", "`include \"path/to/file.vh\"\n"},
+    {"`include    `\"path/to/file.vh`\"\n", "`include `\"path/to/file.vh`\"\n"},
+    {"`define    FOO\n", "`define FOO\n"},
+    {"`define    FOO   BAR\n", "`define FOO BAR\n"},
+    {"`define    FOO\n"
+     "`define  BAR\n",
+     "`define FOO\n"
+     "`define BAR\n"},
+    {"`define FOO_``BAR 1\n", "`define FOO_``BAR 1\n"},
+    {"`define FOO_```BAR 1\n", "`define FOO_```BAR 1\n"},
+    {"`define FOO ``BAR\n", "`define FOO ``BAR\n"},
+    {"`define A``B``C 2\n", "`define A``B``C 2\n"},
+    {"`define A(x)``y\n", "`define A(x) ``y\n"},
+    {"`define    FOO_``BAR\n", "`define FOO_``BAR\n"},
+    {"`ifndef    FOO\n"
+     "`endif // FOO\n",
+     "`ifndef FOO\n"
+     "`endif  // FOO\n"},
+    {"`ifndef    FOO\n"
+     "`define   BAR\n"
+     "`endif\n",
+     "`ifndef FOO\n"
+     "`define BAR\n"
+     "`endif\n"},
+    {"`ifndef    FOO\n"
+     "`define   BAR\n\n"  // one more blank line
+     "`endif\n",
+     "`ifndef FOO\n"
+     "`define BAR\n\n"
+     "`endif\n"},
+    {"`define    FOO   \\\n"
+     "  BAR\n",
+     "`define FOO \\\n"  // TODO(b/72527558): right align '\'s to column limit
+     "  BAR\n"},
+    {"`define    FOOOOOOOOOOOOOOOO   \\\n"
+     "  BAAAAAAAAAAAAAAAAR BAAAAAAAAAAAAAZ;\n",
+     "`define FOOOOOOOOOOOOOOOO \\\n"  // macro text starts at '\'
+     "  BAAAAAAAAAAAAAAAAR BAAAAAAAAAAAAAZ;\n"},
+    {"`ifdef      FOO\n"
+     "  `fine()\n"
+     "`else\n"
+     "  `error()\n"
+     "`endif\n",
+     "`ifdef FOO\n"
+     "`fine()\n"
+     "`else\n"
+     "`error()\n"
+     "`endif\n"},
+    {"`ifdef      FOO\n"
+     "  `fine()\n"
+     "`else // trouble\n"
+     "  `error()\n"
+     "`endif\n",
+     "`ifdef FOO\n"
+     "`fine()\n"
+     "`else  // trouble\n"
+     "`error()\n"
+     "`endif\n"},
+    {"`ifdef      FOO\n"
+     "  `fine()\n"
+     "`else /* trouble */\n"
+     "  `error()\n"
+     "`endif\n",
+     "`ifdef FOO\n"
+     "`fine()\n"
+     "`else  /* trouble */\n"
+     "`error()\n"
+     "`endif\n"},
+    {"    // lonely comment\n", "// lonely comment\n"},
+    {"    // first comment\n"
+     "  // last comment\n",
+     "// first comment\n"
+     "// last comment\n"},
+    {"    // starting comment\n"
+     "  `define   FOO\n",
+     "// starting comment\n"
+     "`define FOO\n"},
+    {"  `define   FOO\n"
+     "   // trailing comment\n",
+     "`define FOO\n"
+     "// trailing comment\n"},
+    {"  `define   FOO\n"
+     "   // trailing comment 1\n"
+     "      // trailing comment 2\n",
+     "`define FOO\n"
+     "// trailing comment 1\n"
+     "// trailing comment 2\n"},
+    {
+        "  `define   FOO    \\\n"  // multiline macro definition
+        " 1\n",
+        "`define FOO \\\n"
+        " 1\n"  // TODO(b/141517267): Reflowing macro definitions
+    },
+    {"`define FOO    \\\n"  // multiline macro definition
+     "        b\n",
+     "`define FOO \\\n"  // no need to align '\'
+     "        b\n"},
+    {"`define FOO    \\\n"  // multiline macro definition
+     "        a +    \\\n"
+     "        b\n",
+     "`define FOO    \\\n"  // preserve spacing before '\'
+     "        a +    \\\n"  // to stay aligned with this one
+     "        b\n"},
+    {"    // comment with backslash\\\n", "// comment with backslash\\\n"},
+    {// macro with MacroArg tokens as arguments
+     "`FOOOOOO(\nbar1...\n,\nbar2...\n,\nbar3...\n,\nbar4\n)\n",
+     "`FOOOOOO(bar1..., bar2..., bar3...,\n"
+     "         bar4)\n"},
+    {// macro declaration exceeds line length limit
+     "`F_MACRO(looooooong_type if_it_fits_I_sits)\n",
+     "`F_MACRO(\n"
+     "    looooooong_type if_it_fits_I_sits)\n"},
+    {// macro call with not fitting arguments
+     "`MACRO_FFFFFFFFFFF("
+     "type_a_aaaa,type_b_bbbbb,"
+     "type_c_cccccc,type_d_dddddddd,"
+     "type_e_eeeeeeee,type_f_ffff)\n",
+     "`MACRO_FFFFFFFFFFF(\n"
+     "    type_a_aaaa, type_b_bbbbb,\n"
+     "    type_c_cccccc, type_d_dddddddd,\n"
+     "    type_e_eeeeeeee, type_f_ffff)\n"},
+    {// nested macro call
+     "`MACRO_FFFFFFFFFFF( "
+     "`A(type_a_aaaa), `B(type_b_bbbbb), "
+     "`C(type_c_cccccc), `D(type_d_dddddddd), "
+     "`E(type_e_eeeeeeee), `F(type_f_ffff))\n",
+     "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa),\n"
+     "                   `B(type_b_bbbbb),\n"
+     "                   `C(type_c_cccccc),\n"
+     "                   `D(type_d_dddddddd),\n"
+     "                   `E(type_e_eeeeeeee),\n"
+     "                   `F(type_f_ffff))\n"},
+    {// two-level nested macro call
+     "`MACRO_FFFFFFFFFFF( "
+     "`A(type_a_aaaa, `B(type_b_bbbbb)), "
+     "`C(type_c_cccccc, `D(type_d_dddddddd)), "
+     "`E(type_e_eeeeeeee, `F(type_f_ffff)))\n",
+     "`MACRO_FFFFFFFFFFF(\n"
+     "    `A(type_a_aaaa, `B(type_b_bbbbb)),\n"
+     "    `C(type_c_cccccc,\n"
+     "       `D(type_d_dddddddd)),\n"
+     "    `E(type_e_eeeeeeee,\n"
+     "       `F(type_f_ffff)))\n"},
+    {// three-level nested macro call
+     "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa,"
+     "`B(type_b_bbbbb,`C(type_c_cccccc))),"
+     "`D(type_d_dddddddd,`E(type_e_eeeeeeee,"
+     "`F(type_f_ffff))))\n",
+     "`MACRO_FFFFFFFFFFF(\n"
+     "    `A(type_a_aaaa,\n"
+     "       `B(type_b_bbbbb,\n"
+     "          `C(type_c_cccccc))),\n"
+     "    `D(type_d_dddddddd,\n"
+     "       `E(type_e_eeeeeeee,\n"
+     "          `F(type_f_ffff))))\n"},
+    {// macro call with MacroArg tokens as arugments and with semicolon
+     "`FOOOOOO(\nbar1...\n,\nbar2...\n,\nbar3...\n,\nbar4\n);\n",
+     "`FOOOOOO(bar1..., bar2..., bar3...,\n"
+     "         bar4);\n"},
+    {// macro declaration exceeds line length limit and contains semicolon
+     "`F_MACRO(looooooong_type if_it_fits_I_sits);\n",
+     "`F_MACRO(\n"
+     "    looooooong_type if_it_fits_I_sits);\n"},
+    {// macro call with not fitting arguments and semicolon
+     "`MACRO_FFFFFFFFFFF("
+     "type_a_aaaa,type_b_bbbbb,"
+     "type_c_cccccc,type_d_dddddddd,"
+     "type_e_eeeeeeee,type_f_ffff);\n",
+     "`MACRO_FFFFFFFFFFF(\n"
+     "    type_a_aaaa, type_b_bbbbb,\n"
+     "    type_c_cccccc, type_d_dddddddd,\n"
+     "    type_e_eeeeeeee, type_f_ffff);\n"},
+    {// nested macro call with semicolon
+     "`MACRO_FFFFFFFFFFF( "
+     "`A(type_a_aaaa), `B(type_b_bbbbb), "
+     "`C(type_c_cccccc), `D(type_d_dddddddd), "
+     "`E(type_e_eeeeeeee), `F(type_f_ffff));\n",
+     "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa),\n"
+     "                   `B(type_b_bbbbb),\n"
+     "                   `C(type_c_cccccc),\n"
+     "                   `D(type_d_dddddddd),\n"
+     "                   `E(type_e_eeeeeeee),\n"
+     "                   `F(type_f_ffff));\n"},
+    {// two-level nested macro call with semicolon
+     "`MACRO_FFFFFFFFFFF( "
+     "`A(type_a_aaaa, `B(type_b_bbbbb)), "
+     "`C(type_c_cccccc, `D(type_d_dddddddd)), "
+     "`E(type_e_eeeeeeee, `F(type_f_ffff)));\n",
+     "`MACRO_FFFFFFFFFFF(\n"
+     "    `A(type_a_aaaa, `B(type_b_bbbbb)),\n"
+     "    `C(type_c_cccccc,\n"
+     "       `D(type_d_dddddddd)),\n"
+     "    `E(type_e_eeeeeeee,\n"
+     "       `F(type_f_ffff)));\n"},
+    {// three-level nested macro call with semicolon
+     "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa,"
+     "`B(type_b_bbbbb,`C(type_c_cccccc))),"
+     "`D(type_d_dddddddd,`E(type_e_eeeeeeee,"
+     "`F(type_f_ffff))));\n",
+     "`MACRO_FFFFFFFFFFF(\n"
+     "    `A(type_a_aaaa,\n"
+     "       `B(type_b_bbbbb,\n"
+     "          `C(type_c_cccccc))),\n"
+     "    `D(type_d_dddddddd,\n"
+     "       `E(type_e_eeeeeeee,\n"
+     "          `F(type_f_ffff))));\n"},
+    {// macro call with no args
+     "`FOOOOOO()\n", "`FOOOOOO()\n"},
+    {// macro call with no args and semicolon
+     "`FOOOOOO();\n", "`FOOOOOO();\n"},
+    {// macro call with no args and semicolon separated by space
+     "`FOOOOOO() ;\n", "`FOOOOOO();\n"},
+    {// macro call with comments in argument list
+     "`FOO(aa, //aa\nbb , // bb\ncc)\n",
+     "`FOO(aa,  //aa\n"
+     "     bb,  // bb\n"
+     "     cc)\n"},
+    {// macro call with comment before first argument
+     "`FOO(//aa\naa, //bb\nbb , // cc\ncc)\n",
+     "`FOO(  //aa\n"
+     "    aa,  //bb\n"
+     "    bb,  // cc\n"
+     "    cc)\n"},
+    {// macro call with argument including trailing EOL comment
+     "`FOO(aa, bb,//cc\ndd)\n",
+     "`FOO(aa, bb,  //cc\n"
+     "     dd)\n"},
+    {// macro call with argument including EOL comment on own line
+     "`FOOOO(aa, bb,\n//cc\ndd)\n",
+     "`FOOOO(aa, bb,\n"
+     "       //cc\n"
+     "       dd)\n"},
+    {"  // leading comment\n"
+     "  `define   FOO    \\\n"  // multiline macro definition
+     "1\n"
+     "   // trailing comment\n",
+     "// leading comment\n"
+     "`define FOO \\\n"
+     "1\n"  // TODO(b/141517267): Reflowing macro definitions
+     "// trailing comment\n"},
+    {// macro call after define
+     "`define   FOO   BAR\n"
+     "  `FOO( bar )\n",
+     "`define FOO BAR\n"
+     "`FOO(bar)\n"},
+    {// multiple argument macro call
+     "  `FOO( bar , baz )\n", "`FOO(bar, baz)\n"},
+    {// long macro call breaking
+     " `ASSERT_INIT(S, (D == 4 && K inside {0, 1}) ||"
+     " (D == 3 && K== 4))\n",
+     "`ASSERT_INIT(\n"
+     "    S, (D == 4 && K inside {0, 1}) ||\n"
+     "           (D == 3 && K == 4))\n"},
+    {// long macro call breaking
+     " `AINIT(S, (D == 4 && K inside {0, 1}) ||"
+     " (D == 3 && K== 4))\n",
+     "`AINIT(S, (D == 4 && K inside {0, 1}) ||\n"
+     "              (D == 3 && K == 4))\n"},
+    {// long macro call breaking
+     " `ASSERT_INIT(S, D == 4 && K inside {0, 1})\n",
+     "`ASSERT_INIT(S,\n"
+     "             D == 4 && K inside {0, 1})\n"},
+    {// macro call in function
+     "function void foo( );   foo=`FOO( bar , baz ) ; endfunction\n",
+     "function void foo();\n"
+     "  foo = `FOO(bar, baz);\n"
+     "endfunction\n"},
+    {// nested macro call in function
+     "function void foo( );   foo=`FOO( `BAR ( baz ) ) ; endfunction\n",
+     "function void foo();\n"
+     "  foo = `FOO(`BAR(baz));\n"
+     "endfunction\n"},
+    {// macro call in class
+     "class foo;    `FOO  ( bar , baz ) ; endclass\n",
+     "class foo;\n"
+     "  `FOO(bar, baz);\n"
+     "endclass\n"},
+    {// nested macro call in class
+     "class foo;    `FOO  ( `BAR ( baz1 , baz2 ) ) ; endclass\n",
+     "class foo;\n"
+     "  `FOO(`BAR(baz1, baz2));\n"
+     "endclass\n"},
+    {// multi-line macro arg "aaaa..." should start on its own line,
+     // even if its first line would fit under the column limit
+     "`CHECK_FATAL(rd_tr,\n"
+     "             aaaa     == zzz;\n"
+     "             ggg      == vv::w;,\n"
+     "             \"Failed to ..........\")\n",
+     "`CHECK_FATAL(rd_tr,\n"
+     "             aaaa     == zzz;\n"
+     "             ggg      == vv::w;,\n"
+     "             \"Failed to ..........\")\n"},
+    {// macro call nested with function call containing an ifdef
+     "`J(D(`ifdef e))\n",
+     "`J(D(\n"
+     "   `ifdef e))\n"},
+
+    // `uvm macros indenting
+    {
+        // simple test case
+        "`uvm_object_utils_begin(aa)\n"
+        "`uvm_field_int(bb, UVM_DEFAULT)\n"
+        "`uvm_field_int(cc, UVM_DEFAULT)\n"
+        "`uvm_object_utils_end\n",
+        "`uvm_object_utils_begin(aa)\n"
+        "  `uvm_field_int(bb, UVM_DEFAULT)\n"
+        "  `uvm_field_int(cc, UVM_DEFAULT)\n"
+        "`uvm_object_utils_end\n",
+    },
+    {// multiple uvm.*begin - uvm.*end ranges
+     "`uvm_object_utils_begin(aa)\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_object_utils_end\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_object_utils_begin(bb)\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_object_utils_end\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(cc, UVM_DEFAULT)\n",
+     "`uvm_object_utils_begin(aa)\n"
+     "  `uvm_field_int(bb, UVM_DEFAULT)\n"
+     "  `uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_object_utils_end\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_object_utils_begin(bb)\n"
+     "  `uvm_field_int(bb, UVM_DEFAULT)\n"
+     "  `uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_object_utils_end\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(cc, UVM_DEFAULT)\n"},
+    {
+        // empty uvm.*begin - uvm.*end range
+        "`uvm_component_utils_begin(aa)\n"
+        "`uvm_component_utils_end\n",
+        "`uvm_component_utils_begin(aa)\n"
+        "`uvm_component_utils_end\n",
+    },
+    {
+        // uvm_field_utils
+        "`uvm_field_utils_begin(aa)\n"
+        "`uvm_field_int(bb, UVM_DEFAULT)\n"
+        "`uvm_field_int(cc, UVM_DEFAULT)\n"
+        "`uvm_field_utils_end\n",
+        "`uvm_field_utils_begin(aa)\n"
+        "  `uvm_field_int(bb, UVM_DEFAULT)\n"
+        "  `uvm_field_int(cc, UVM_DEFAULT)\n"
+        "`uvm_field_utils_end\n",
+    },
+    {
+        // uvm_component
+        "`uvm_component_utils_begin(aa)\n"
+        "`uvm_field_int(bb, UVM_DEFAULT)\n"
+        "`uvm_field_int(cc, UVM_DEFAULT)\n"
+        "`uvm_component_utils_end\n",
+        "`uvm_component_utils_begin(aa)\n"
+        "  `uvm_field_int(bb, UVM_DEFAULT)\n"
+        "  `uvm_field_int(cc, UVM_DEFAULT)\n"
+        "`uvm_component_utils_end\n",
+    },
+    {
+        // nested uvm macros
+        "`uvm_field_int(l0, UVM_DEFAULT)\n"
+        "`uvm_component_utils_begin(l0)\n"
+        "`uvm_field_int(l1, UVM_DEFAULT)\n"
+        "`uvm_component_utils_begin(l1)\n"
+        "`uvm_field_int(l2, UVM_DEFAULT)\n"
+        "`uvm_component_utils_begin(l2)\n"
+        "`uvm_field_int(l3, UVM_DEFAULT)\n"
+        "`uvm_component_utils_end\n"
+        "`uvm_field_int(l2, UVM_DEFAULT)\n"
+        "`uvm_component_utils_end\n"
+        "`uvm_field_int(l1, UVM_DEFAULT)\n"
+        "`uvm_component_utils_end\n"
+        "`uvm_field_int(l0, UVM_DEFAULT)\n",
+        "`uvm_field_int(l0, UVM_DEFAULT)\n"
+        "`uvm_component_utils_begin(l0)\n"
+        "  `uvm_field_int(l1, UVM_DEFAULT)\n"
+        "  `uvm_component_utils_begin(l1)\n"
+        "    `uvm_field_int(l2, UVM_DEFAULT)\n"
+        "    `uvm_component_utils_begin(l2)\n"
+        "      `uvm_field_int(l3, UVM_DEFAULT)\n"
+        "    `uvm_component_utils_end\n"
+        "    `uvm_field_int(l2, UVM_DEFAULT)\n"
+        "  `uvm_component_utils_end\n"
+        "  `uvm_field_int(l1, UVM_DEFAULT)\n"
+        "`uvm_component_utils_end\n"
+        "`uvm_field_int(l0, UVM_DEFAULT)\n",
+    },
+    {
+        // non-uvm macro
+        "`my_macro_begin(aa)\n"
+        "`my_field(b)\n"
+        "`my_field(c)\n"
+        "`my_macro_end\n",
+        "`my_macro_begin(aa)\n"
+        "`my_field(b)\n"
+        "`my_field(c)\n"
+        "`my_macro_end\n",
+    },
+    {
+        // unbalanced uvm macros: missing uvm.*end macro
+        "`uvm_component_utils_begin(aa)\n"
+        "`uvm_field_int(bb, UVM_DEFAULT)\n"
+        "`uvm_field_int(cc, UVM_DEFAULT)\n",
+        "`uvm_component_utils_begin(aa)\n"
+        "`uvm_field_int(bb, UVM_DEFAULT)\n"
+        "`uvm_field_int(cc, UVM_DEFAULT)\n",
+    },
+    {
+        // unbalanced uvm macros: missing uvm.*begin macro
+        "`uvm_field_int(bb, UVM_DEFAULT)\n"
+        "`uvm_field_int(cc, UVM_DEFAULT)\n"
+        "`uvm_component_utils_end\n",
+        "`uvm_field_int(bb, UVM_DEFAULT)\n"
+        "`uvm_field_int(cc, UVM_DEFAULT)\n"
+        "`uvm_component_utils_end\n",
+    },
+    {// unbalanced uvm macros: missing _begin macro between
+     // matching uvm.*begin-uvm.*end macros
+     "`uvm_component_utils_begin(aa)\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_component_utils_end\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_component_utils_end\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_component_utils_begin(aa)\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_component_utils_end\n",
+     "`uvm_component_utils_begin(aa)\n"
+     "  `uvm_field_int(bb, UVM_DEFAULT)\n"
+     "  `uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_component_utils_end\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_component_utils_end\n"
+     "`uvm_field_int(bb, UVM_DEFAULT)\n"
+     "`uvm_component_utils_begin(aa)\n"
+     "  `uvm_field_int(bb, UVM_DEFAULT)\n"
+     "  `uvm_field_int(cc, UVM_DEFAULT)\n"
+     "`uvm_component_utils_end\n"},
+
+    // top-level directive test cases
+    {"`timescale  1ns/1ps\n",  //
+     "`timescale 1ns / 1ps\n"},
+
+    // Multiple compiler directives should remain on separate lines
+    // (regression test for bug where they were merged onto one line)
+    {"`timescale 1 ps / 1 ps\n"
+     "`default_nettype none\n",
+     "`timescale 1 ps / 1 ps\n"
+     "`default_nettype none\n"},
+    {"`resetall\n"
+     "`timescale 1ns/1ps\n"
+     "`default_nettype wire\n",
+     "`resetall\n"
+     "`timescale 1ns / 1ps\n"
+     "`default_nettype wire\n"},
+    // Test with multiple different compiler directives
+    {"`resetall\n"
+     "`celldefine\n"
+     "`timescale 1ns/1ps\n"
+     "`default_nettype none\n",
+     "`resetall\n"
+     "`celldefine\n"
+     "`timescale 1ns / 1ps\n"
+     "`default_nettype none\n"},
+    // Test with compiler directives before module
+    {"`timescale 1ps/1ps\n"
+     "`default_nettype none\n"
+     "module foo;endmodule\n",
+     "`timescale 1ps / 1ps\n"
+     "`default_nettype none\n"
+     "module foo;\nendmodule\n"},
+    // Test with various compiler directives
+    {"`suppress_faults\n"
+     "`enable_portfaults\n"
+     "`delay_mode_distributed\n",
+     "`suppress_faults\n"
+     "`enable_portfaults\n"
+     "`delay_mode_distributed\n"},
+    {"`default_decay_time 10\n"
+     "`default_trireg_strength 50\n",
+     "`default_decay_time 10\n"
+     "`default_trireg_strength 50\n"},
+    // Alignment should ignore compiler directives; declarations align normally.
+    // Place directives at top-level between modules (valid SystemVerilog).
+    {"`timescale 1ns/1ps\n"
+     "module m;\n"
+     "  logic a;\n"
+     "  logic very_long_name;\n"
+     "endmodule\n"
+     "`default_nettype none\n"
+     "module n;\n"
+     "  logic b;\n"
+     "endmodule\n",
+     "`timescale 1ns / 1ps\n"
+     "module m;\n"
+     "  logic a;\n"
+     "  logic very_long_name;\n"
+     "endmodule\n"
+     "`default_nettype none\n"
+     "module n;\n"
+     "  logic b;\n"
+     "endmodule\n"},
+    {"`begin_keywords \"1800-2017\"\n"
+     "module test;endmodule\n"
+     "`end_keywords\n",
+     "`begin_keywords \"1800-2017\"\n"
+     "module test;\nendmodule\n"
+     "`end_keywords\n"},
+
+};
+
+TEST(FormatterEndToEndTest, MacroFormatterTestCases) {
+  RunFormatterTestCases40(kMacroFormatterTestCases);
+}
+
+}  // namespace
+}  // namespace formatter
+}  // namespace verilog
diff --git a/verible/verilog/formatting/formatter_module_test.cc b/verible/verilog/formatting/formatter_module_test.cc
new file mode 100644
index 0000000..4290e5e
--- /dev/null
+++ b/verible/verilog/formatting/formatter_module_test.cc
@@ -0,0 +1,3025 @@
+// Copyright 2017-2026 The Verible Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Test cases in this file should be *insensitive* to wrapping penalties.
+// Penalty-sensitive tests belong in formatter-tuning_test.cc.
+
+#include "gtest/gtest.h"
+#include "verible/verilog/formatting/formatter-test-utils.h"
+
+namespace verilog {
+namespace formatter {
+namespace {
+
+static constexpr FormatterTestCase kModuleFormatterTestCases[] = {
+    // parameter test cases
+    {
+        "  parameter  int   foo=0 ;",
+        "parameter int foo = 0;\n",
+    },
+    {
+        "  parameter  int   foo=bar [ 0 ] ;",  // index expression
+        "parameter int foo = bar[0];\n",
+    },
+    {
+        "  parameter  int   foo=bar [ a+b ] ;",  // binary inside index expr
+        "parameter int foo = bar[a+b];\n",       // allowed to be 0 spaces
+                                                 // (preserved)
+    },
+    {
+        "  parameter  int   foo=bar [ a+ b ] ;",  // binary inside index expr
+        "parameter int foo = bar[a+b];\n",        // allowed to be 0 spaces
+                                                  // (symmetrized)
+    },
+    {
+        "  parameter  int   foo=bar [ a +b ] ;",  // compact binary inside
+        "parameter int foo = bar[a+b];\n",        // index expression
+    },
+    {
+        "  parameter  int   foo=bar [ a  +b ] ;",  // compact binary inside
+        "parameter int foo = bar[a+b];\n",         // index expression
+    },
+    {
+        // with line continuations
+        "  parameter  \\\nint   \\\nfoo=a+ \\\nb ;",
+        "parameter\\\n    int\\\n    foo = a +\\\n    b;\n",
+        // TODO(fangism): should text following a line continuation hang-indent?
+    },
+    // unary prefix expressions
+    {
+        "  parameter  int   foo=- 1 ;",
+        "parameter int foo = -1;\n",
+    },
+    {
+        "  parameter  int   foo=+ 7 ;",
+        "parameter int foo = +7;\n",
+    },
+    {
+        "  parameter  int   foo=- J ;",
+        "parameter int foo = -J;\n",
+    },
+    {
+        "  parameter  int   foo=- ( y ) ;",
+        "parameter int foo = -(y);\n",
+    },
+    {
+        "  parameter  int   foo=- ( z*y ) ;",
+        "parameter int foo = -(z * y);\n",
+    },
+    {
+        "  parameter  int   foo=-  z*- y  ;",
+        "parameter int foo = -z * -y;\n",
+    },
+    {
+        "  parameter  int   foo=( - 2 ) ;",  //
+        "parameter int foo = (-2);\n",
+    },
+    {
+        "  parameter  int   foo=$bar(-  z,- y ) ;",
+        "parameter int foo = $bar(-z, -y);\n",
+    },
+    {"  parameter int a=b&~(c<<d);", "parameter int a = b & ~(c << d);\n"},
+    {"  parameter int a=~~~~b;", "parameter int a = ~~~~b;\n"},
+    {"  parameter int a = ~ ~ ~ ~ b;", "parameter int a = ~~~~b;\n"},
+    {"  parameter int a   =   ~--b;", "parameter int a = ~--b;\n"},
+    {"  parameter int a   =   ~ --b;", "parameter int a = ~--b;\n"},
+    {"  parameter int a = ~ ++ b;", "parameter int a = ~++b;\n"},
+    {"  parameter int a=--b- --c;", "parameter int a = --b - --c;\n"},
+    // ^~ and ~^ are bitwise nor, but ^ ~ isn't
+    {"  parameter int a=b^~(c<<d);", "parameter int a = b ^~ (c << d);\n"},
+    {"  parameter int a=b~^(c<<d);", "parameter int a = b ~^ (c << d);\n"},
+    {"  parameter int a=b^ ~ (c<<d);", "parameter int a = b ^ ~(c << d);\n"},
+    {"  parameter int a=b ^ ~(c<<d);", "parameter int a = b ^ ~(c << d);\n"},
+
+    {"  parameter int a=b^~{c};", "parameter int a = b ^~ {c};\n"},
+    {"  parameter int a=b~^{c};", "parameter int a = b ~^ {c};\n"},
+    {"  parameter int a=b^ ~ {c};", "parameter int a = b ^ ~{c};\n"},
+    {"  parameter int a=b ^ ~{c};", "parameter int a = b ^ ~{c};\n"},
+
+    {"  parameter int a={a}^{b};", "parameter int a = {a} ^ {b};\n"},
+    {"  parameter int a={b}^(c);", "parameter int a = {b} ^ (c);\n"},
+    {"  parameter int a=b[0]^ {c};", "parameter int a = b[0] ^ {c};\n"},
+    {"  parameter int a={c}^a[b];", "parameter int a = {c} ^ a[b];\n"},
+    {"  parameter int a=(c)^{a[b]};", "parameter int a = (c) ^ {a[b]};\n"},
+
+    {"  parameter int a={^{a,^b},c};", "parameter int a = {^{a, ^b}, c};\n"},
+    {"  parameter int a=(a)^(^d[e]^{c});",
+     "parameter int a = (a) ^ (^d[e] ^ {c});\n"},
+    {"  parameter int a=(a)^(^d[e]^f[g]);",
+     "parameter int a = (a) ^ (^d[e] ^ f[g]);\n"},
+    {"  parameter int a=(b^(c^(d^e)));",
+     "parameter int a = (b ^ (c ^ (d ^ e)));\n"},
+    {"  parameter int a={b^{c^{d^e}}};",
+     "parameter int a = {b ^ {c ^ {d ^ e}}};\n"},
+    {"  parameter int a={b^{c[d^e]}};",
+     "parameter int a = {b ^ {c[d^e]}};\n"},  // allow 0 spaces inside "[d^e]"
+    {"  parameter int a={(b^c),(d^^e)};",
+     "parameter int a = {(b ^ c), (d ^ ^e)};\n"},
+
+    {"  parameter int a={(b[x]^{c[y]})};",
+     "parameter int a = {(b[x] ^ {c[y]})};\n"},
+    {"  parameter int a={d^^e[f] ^ (g)};",
+     "parameter int a = {d ^ ^e[f] ^ (g)};\n"},
+
+    // ~| is unary reduction NOR, |~ and | ~ aren't
+    {"  parameter int a=b| ~(c<<d);", "parameter int a = b | ~(c << d);\n"},
+    {"  parameter int a=b|~(c<<d);", "parameter int a = b | ~(c << d);\n"},
+    {"  parameter int a=b| ~| ( c<<d);", "parameter int a = b | ~|(c << d);\n"},
+    {"  parameter int a=b| ~| ~| ( c<<d);",
+     "parameter int a = b | ~|~|(c << d);\n"},
+    {"  parameter int a=b| ~~~( c<<d);",
+     "parameter int a = b | ~~~(c << d);\n"},
+    {
+        "  parameter  int   foo=- - 1 ;",  // double negative
+        "parameter int foo = - -1;\n",
+    },
+    {
+        "  parameter  int   ternary=1?2:3;",
+        "parameter int ternary = 1 ? 2 : 3;\n",
+    },
+    {
+        "  parameter  int   ternary=a?b:c;",
+        "parameter int ternary = a ? b : c;\n",
+    },
+    {
+        "  parameter  int   ternary=\"a\"?\"b\":\"c\";",
+        "parameter int ternary = \"a\" ? \"b\" : \"c\";\n",
+    },
+    {
+        "  parameter  int   t=`\"a`\"?`\"b`\":`\"c`\";",
+        "parameter int t = `\"a`\" ? `\"b`\" : `\"c`\";\n",
+    },
+    {
+        "  parameter  int   ternary=(a)?(b):(c);",
+        "parameter int ternary = (a) ? (b) : (c);\n",
+    },
+    {
+        "  parameter  int   ternary={a}?{b}:{c};",
+        "parameter int ternary = {a} ? {b} : {c};\n",
+    },
+    {
+        "  parameter  int   long_ternary=cond?long_option_t:long_option_f;",
+        "parameter int long_ternary = cond ?\n"
+        "    long_option_t : long_option_f;\n",
+    },
+    {
+        "  parameter  int   break_two=cond\n"
+        "? a_really_long_option_number_one:a_really_long_option_number_two;",
+        "parameter int break_two = cond ?\n"
+        "    a_really_long_option_number_one :\n"
+        "    a_really_long_option_number_two;\n",
+    },
+    {
+        "  assign   ternary=1?2:3;",
+        "assign ternary = 1 ? 2 : 3;\n",
+    },
+    {
+        "  assign   ternary=a?b:c;",
+        "assign ternary = a ? b : c;\n",
+    },
+    {
+        "  assign   ternary={a}?{b}:{c};",
+        "assign ternary = {a} ? {b} : {c};\n",
+    },
+    {
+        "  assign   break_two=cond\n"
+        "? a_really_long_option_number_one:a_really_long_option_number_two;",
+        "assign break_two = cond ?\n"
+        "    a_really_long_option_number_one :\n"
+        "    a_really_long_option_number_two;\n",
+    },
+    {
+        "assign prefetch_d     =\n"
+        "lookup_grant_ic0 ? (lookup_addr_aligned + ADDR) :\n"
+        "                   addr_i;",
+        "assign prefetch_d = lookup_grant_ic0 ?\n"
+        "    (lookup_addr_aligned + ADDR) :\n"
+        "    addr_i;\n",
+    },
+    {
+        "assign prefetch_d     =\n"
+        "lookup_grant_ic0 ? (lookup_addr + 1) :\n"
+        "                   addr_i;",
+        "assign prefetch_d = lookup_grant_ic0 ?\n"
+        "    (lookup_addr + 1) : addr_i;\n",
+    },
+    {
+        "module test;\n"
+        " assign next = // EOL\n"
+        "  foo ? '0 :\n"
+        "  cnt;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next =  // EOL\n"
+        "      foo ? '0 : cnt;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo // EOL\n"
+        "  ? '0 :\n"
+        "  cnt;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo  // EOL\n"
+        "      ? '0 : cnt;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo ? // EOL\n"
+        "  '0 :\n"
+        "  cnt;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo ?  // EOL\n"
+        "      '0 : cnt;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo ? '0 // EOL\n"
+        "  :\n"
+        "  cnt;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo ? '0  // EOL\n"
+        "      : cnt;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo ? '0 : // EOL\n"
+        "  cnt;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo ? '0 :  // EOL\n"
+        "      cnt;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo ? '0 : // EOL\n"
+        "  bar ? '1 : '0;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo ? '0 :  // EOL\n"
+        "      bar ? '1 : '0;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo ? '0 : // EOL\n"
+        "  bar // EOL2\n"
+        " ? '1 : '0;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo ? '0 :  // EOL\n"
+        "      bar  // EOL2\n"
+        "      ? '1 : '0;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo ? '0 : // EOL\n"
+        "  bar ? // EOL2\n"
+        "  '1 : '0;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo ? '0 :  // EOL\n"
+        "      bar ?  // EOL2\n"
+        "      '1 : '0;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo ? '0 : // EOL\n"
+        "  bar ? '1 // EOL2\n"
+        "  : '0;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo ? '0 :  // EOL\n"
+        "      bar ? '1  // EOL2\n"
+        "      : '0;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo ? '0 : // EOL\n"
+        "  bar ? '1 : // EOL2\n"
+        "  '0;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo ? '0 :  // EOL\n"
+        "      bar ? '1 :  // EOL2\n"
+        "      '0;\n"
+        "endmodule\n",
+    },
+    {
+        "assign prefetch_d     =\n"
+        "lookup_ic0 ? // EOL\n"
+        " (lookup_addr + 1) :// BOO\n"
+        "                   addr_i;",
+        "assign prefetch_d = lookup_ic0 ?  // EOL\n"
+        "    (lookup_addr + 1) :  // BOO\n"
+        "    addr_i;\n",
+    },
+    {
+        "module test;\n"
+        " assign next = (foo) ? '0          : // clear \n"
+        "           (bar) ? cnt + 1'b1  : // count \n"
+        "                   cnt;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = (foo) ? '0 :  // clear \n"
+        "      (bar) ? cnt + 1'b1 :  // count \n"
+        "      cnt;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = // FOO\n"
+        "  (foo) ? '0          : // clear \n"
+        "           (bar) ? cnt + 1'b1  : // count \n"
+        "                   cnt;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next =  // FOO\n"
+        "      (foo) ? '0 :  // clear \n"
+        "      (bar) ? cnt + 1'b1 :  // count \n"
+        "      cnt;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo ? a_really_long_identifier : // EOL\n"
+        "  cnt;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo ?\n"
+        "      a_really_long_identifier :  // EOL\n"
+        "      cnt;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo ? a_really_long_identifier : // EOL\n"
+        "  another_really_long_identifier;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo ?\n"
+        "      a_really_long_identifier :  // EOL\n"
+        "      another_really_long_identifier;\n"
+        "endmodule\n",
+    },
+    {
+        "module test;\n"
+        " assign next = foo ? a_really_long_identifier : "
+        "another_really_long_identifier;\n"
+        "endmodule\n",
+        "module test;\n"
+        "  assign next = foo ?\n"
+        "      a_really_long_identifier :\n"
+        "      another_really_long_identifier;\n"
+        "endmodule\n",
+    },
+    {
+        "assign m = check                ? {10'b0, foo} :\n"
+        "           (bar && (baz == '0)) ? hello        :\n"
+        "           world                ? temp1        : temp2;\n",
+        "assign m = check ? {10'b0, foo} :\n"
+        "    (bar && (baz == '0)) ? hello :\n"
+        "    world ? temp1 : temp2;\n",
+    },
+    {
+        "assign {a, b} = !(c == d) ? {1'b0, e} :\n"
+        "                ((e == f) && g) ?\n"
+        "                {1'b0, f} : (h) ?\n"
+        "                {1'b0, e} - 1'b1 :\n"
+        "                {1'b0, e} + 1'b1;\n",
+        "assign {a, b} = !(c == d) ? {1'b0, e} :\n"
+        "    ((e == f) && g) ? {1'b0, f} : (h) ?\n"
+        "    {1'b0, e} - 1'b1 : {1'b0, e} + 1'b1;\n",
+    },
+    {
+        "assign {aaaaaaaaaa, bbbbbbbbb} = {1'b0, cccccccccccccccccc[15:0]} +\n"
+        "                                 {1'b0, ddddddddddddddddd[15:0]};\n",
+        "assign {aaaaaaaaaa, bbbbbbbbb} =\n"
+        "    {1'b0, cccccccccccccccccc[15:0]} +\n"
+        "    {1'b0, ddddddddddddddddd[15:0]};\n",
+    },
+    {
+        "covergroup a(string b);\n"
+        "foobar: cross foo, bar {"
+        "ignore_bins baz = binsof(qux) intersect {1, 2, 3, 4, 5, 6, 7};"
+        "}\n"
+        "endgroup : a\n",
+        "covergroup a(string b);\n"
+        "  foobar: cross foo, bar{\n"
+        "    ignore_bins baz =\n"
+        "        binsof (qux) intersect {\n"
+        "      1, 2, 3, 4, 5, 6, 7\n"
+        "    };\n"
+        "  }\n"
+        "endgroup : a\n",
+    },
+    {
+        "assign {aa, bb} = {1'b0, cc} + {1'b0, dd};\n",
+        "assign {aa, bb} = {1'b0, cc} +\n"
+        "    {1'b0, dd};\n",
+    },
+
+    // streaming operators
+    {
+        "   parameter  int  b={ >>   { a } } ;",
+        "parameter int b = {>>{a}};\n",
+    },
+    {
+        "   parameter  int  b={ >>   { a , b,  c } } ;",
+        "parameter int b = {>>{a, b, c}};\n",
+    },
+    {
+        "   parameter  int  b={ >> 4  { a } } ;",
+        "parameter int b = {>>4{a}};\n",
+    },
+    {
+        "   parameter  int  b={ >> byte  { a } } ;",
+        "parameter int b = {>>byte{a}};\n",
+    },
+    {
+        "   parameter  int  b={ >> my_type_t  { a } } ;",
+        "parameter int b = {>>my_type_t{a}};\n",
+    },
+    {
+        "   parameter  int  b={ >> `GET_TYPE  { a } } ;",
+        "parameter int b = {>>`GET_TYPE{a}};\n",
+    },
+    {
+        "   parameter  int  b={ >> 4  {{ >> 2 { a }  }} } ;",
+        "parameter int b = {>>4{{>>2{a}}}};\n",
+    },
+    {
+        "   parameter  int  b={ <<   { a } } ;",
+        "parameter int b = {<<{a}};\n",
+    },
+    {
+        "   parameter  int  b={ <<   { a , b,  c } } ;",
+        "parameter int b = {<<{a, b, c}};\n",
+    },
+    {
+        "   parameter  int  b={ << 4  { a } } ;",
+        "parameter int b = {<<4{a}};\n",
+    },
+    {
+        "   parameter  int  b={ << byte  { a } } ;",
+        "parameter int b = {<<byte{a}};\n",
+    },
+    {
+        "   parameter  int  b={ << my_type_t  { a } } ;",
+        "parameter int b = {<<my_type_t{a}};\n",
+    },
+    {
+        "   parameter  int  b={ << `GET_TYPE  { a } } ;",
+        "parameter int b = {<<`GET_TYPE{a}};\n",
+    },
+    {
+        "   parameter  int  b={ << 4  {{ << 2 { a }  }} } ;",
+        "parameter int b = {<<4{{<<2{a}}}};\n",
+    },
+
+    // basic module test cases
+    {"module foo;endmodule:foo\n",
+     "module foo;\n"
+     "endmodule : foo\n"},
+    {"module\nfoo\n;\nendmodule\n:\nfoo\n",
+     "module foo;\n"
+     "endmodule : foo\n"},
+    {"module\tfoo\t;\tendmodule\t:\tfoo",
+     "module foo;\n"
+     "endmodule : foo\n"},
+    {"module foo;     // foo\n"
+     "endmodule:foo\n",
+     "module foo;  // foo\n"
+     "endmodule : foo\n"},
+    {"module foo;/* foo */endmodule:foo\n",
+     "module foo;  /* foo */\n"
+     "endmodule : foo\n"},
+    {"module pm #(\n"
+     "//comment\n"
+     ") (wire ww);\n"
+     "endmodule\n",
+     "module pm #(\n"
+     "    //comment\n"  // comment indented
+     ") (\n"
+     "    wire ww\n"
+     ");\n"
+     "endmodule\n"},
+    {"module pm ( ) ;\n"  // empty ports list
+     "endmodule\n",
+     "module pm ();\n"
+     "endmodule\n"},
+    {"module pm #(\n"
+     "//comment\n"
+     ") ( );\n"
+     "endmodule\n",
+     "module pm #(\n"
+     "    //comment\n"  // comment indented
+     ") ();\n"          // (); grouped together
+     "endmodule\n"},
+    {"`ifdef FOO\n"
+     "    `ifndef BAR\n"
+     "    `endif\n"
+     "`endif\n",
+     "`ifdef FOO\n"
+     "`ifndef BAR\n"
+     "`endif\n"
+     "`endif\n"},
+    {"module foo(\n"
+     "       `include \"ports.svh\"\n"
+     "         ) ; endmodule\n",
+     "module foo (\n"
+     "    `include \"ports.svh\"\n"
+     ");\n"
+     "endmodule\n"},
+    {"module foo(\n"
+     "       `define FOO\n"
+     "`undef\tFOO\n"
+     "         ) ; endmodule\n",
+     "module foo (\n"
+     "    `define FOO\n"
+     "    `undef FOO\n"
+     ");\n"
+     "endmodule\n"},
+    {"module foo(  input x  , output y ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  x,\n"  // aligned
+     "    output y\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(\n"
+     "// comment\n"
+     "  input x  , output y ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    // comment\n"
+     "    input  x,\n"  // aligned
+     "    output y\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input[2:0]x  , output y [3:0] ) ;endmodule:foo\n",
+     // each port item should be on its own line
+     "module foo (\n"
+     "    input  [2:0] x,\n"  // aligned
+     "    output       y[3:0]\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire x  , output reg yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire x,\n"  // aligned
+     "    output reg  yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire x  ,//c1\n"
+     "output reg yyy //c2\n"
+     " ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire x,   //c1\n"  // aligned
+     "    output reg  yyy  //c2\n"  // aligned
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire x  ,/* c1 */\n"
+     "output reg yyy /* c2 */\n"
+     " ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire x,   /* c1 */\n"  // aligned
+     "    output reg  yyy  /* c2 */\n"  // aligned
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(\n"
+     "// comment\n"
+     "input wire x  ,//c1\n"
+     "output reg yyy //c2\n"
+     " ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    // comment\n"
+     "    input  wire x,   //c1\n"  // aligned
+     "    output reg  yyy  //c2\n"  // aligned
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(\n"
+     "/* comment */\n"
+     "input wire x  ,/* c1 */\n"
+     "output reg yyy /* c2 */\n"
+     " ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    /* comment */\n"
+     "    input  wire x,   /* c1 */\n"  // aligned
+     "    output reg  yyy  /* c2 */\n"  // aligned
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire x  ,/* c1\n"
+     "c2\n"
+     "c3 */\n"
+     "output reg yyy /* c4 */\n"
+     " ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire x,   /* c1\n"
+     "c2\n"
+     "c3 */\n"  // TODO: align multiline comments
+     "    output reg  yyy  /* c4 */\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire x  ,/* c1 */\n"
+     "output reg yyy,\n"
+     "output z // c2\n"
+     " ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire x,    /* c1 */\n"  // aligned
+     "    output reg  yyy,\n"
+     "    output      z     // c2\n"  // aligned
+     ");\n"
+     "endmodule : foo\n"},
+    {"module m(input logic [4:0] foo,  // comment\n"
+     "input logic bar // comment\n"
+     " ) ;endmodule:m\n",
+     "module m (\n"
+     "    input logic [4:0] foo,  // comment\n"  // aligned
+     "    input logic       bar   // comment\n"  // aligned
+     ");\n"
+     "endmodule : m\n"},
+    {"module foo(  input wire x  , output yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire x,\n"  // aligned
+     "    output      yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input   x  , output reg yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input      x,\n"  // aligned
+     "    output reg yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input   x  , output reg[a:b]yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input            x,\n"  // aligned
+     "    output reg [a:b] yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input   [a:b]x  , output reg  yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input      [a:b] x,\n"  // aligned
+     "    output reg       yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input   x  , "
+     "  output logic  yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input        x,\n"  // aligned
+     "    output logic yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input   [a:c]x  , "
+     "  output logic[a-b: c]  yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input        [  a:c] x,\n"  // aligned
+     "    output logic [a-b:c] yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input   [a:c]x  , "
+     "  output logic[a - b: c]  yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input        [    a:c] x,\n"  // aligned
+     "    output logic [a - b:c] yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input   [a:c]x  , input zzz ,"
+     "  output logic[a - b: c]  yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input        [    a:c] x,\n"    // aligned []'s
+     "    input                  zzz,\n"  // aligned ids
+     "    output logic [a - b:c] yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input   [a:b]x  , "
+     "  output reg[e: f]  yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input      [a:b] x,\n"  // aligned
+     "    output reg [e:f] yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input   tri[aa: bb]x  , "
+     "  output reg[e: f]  yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  tri [aa:bb] x,\n"  // aligned
+     "    output reg [  e:f] yy\n"  // TODO(b/70310743): align ':'
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input   [a:b][c:d]x  , "
+     "  output reg[e: f]  yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input      [a:b][c:d] x,\n"  // aligned
+     "    output reg [e:f]      yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire x  [j:k], output reg yy ) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire x [j:k],\n"  // aligned
+     "    output reg  yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire x  , output reg yy [j:k]) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire x,\n"  // aligned
+     "    output reg  yy[j:k]\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire x  [p:q], output reg yy [j:k]) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire x [p:q],\n"  // aligned
+     "    output reg  yy[j:k]\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire x  [p:q][r:s], output reg yy [j:k]) "
+     ";endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire x [p:q][r:s],\n"  // aligned
+     "    output reg  yy[j:k]\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire x  [p:q][rr:ss], output reg yy [jj:kk][m:n]) "
+     ";endmodule:foo\n",
+     "module foo (\n"
+     // TODO(b/70310743): align :'s
+     "    input  wire x [  p:q][rr:ss],\n"
+     "    output reg  yy[jj:kk][  m:n]\n"  // aligned
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire   [p:q]x, output reg yy [j:k]) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire [p:q] x,\n"  // aligned
+     "    output reg        yy[j:k]\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire  x [p:q], output reg[j:k]yy) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire       x [p:q],\n"  // aligned
+     "    output reg  [j:k] yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input pkg::bar_t  x , output reg  yy) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  pkg::bar_t x,\n"  // aligned
+     "    output reg        yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input wire  x , output pkg::bar_t  yy) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  wire       x,\n"  // aligned
+     "    output pkg::bar_t yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input pkg::bar_t#(1)  x , output reg  yy) ;endmodule:foo\n",
+     "module foo (\n"  // with parameterized port type
+     "    input  pkg::bar_t#(1) x,\n"
+     "    output reg            yy\n"  // aligned
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input signed x , output reg  yy) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  signed x,\n"  // aligned
+     "    output reg    yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input signed x , output reg [m:n] yy) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  signed       x,\n"  // aligned
+     "    output reg    [m:n] yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input int signed x , output reg [m:n] yy) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  int signed       x,\n"  // aligned
+     "    output reg        [m:n] yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(  input signed x , output pkg::bar_t  yy) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input  signed     x,\n"  // aligned
+     "    output pkg::bar_t yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module somefunction ("
+     "logic clk, int   a, int b);endmodule",
+     "module somefunction (\n"
+     "    logic clk,\n"  // direction missing
+     "    int   a,\n"    // direction missing
+     "    int   b\n"     // direction missing
+     ");\n"
+     "endmodule\n"},
+    {"module somefunction ("
+     "logic clk, input int   a, int b);endmodule",
+     "module somefunction (\n"
+     "          logic clk,\n"  // direction missing
+     "    input int   a,\n"
+     "          int   b\n"  // direction missing
+     ");\n"
+     "endmodule\n"},
+    {"module somefunction ("
+     "input logic clk, input int   a, int b);endmodule",
+     "module somefunction (\n"
+     "    input logic clk,\n"
+     "    input int   a,\n"
+     "          int   b\n"  // direction missing
+     ");\n"
+     "endmodule\n"},
+    {"module somefunction ("
+     "input clk, input int   a, int b);endmodule",
+     "module somefunction (\n"
+     "    input     clk,\n"  // type missing
+     "    input int a,\n"
+     "          int b\n"
+     ");\n"
+     "endmodule\n"},
+    {"module somefunction ("
+     "input logic clk, input a, int b);endmodule",
+     "module somefunction (\n"
+     "    input logic clk,\n"
+     "    input       a,\n"  // type missing
+     "          int   b\n"   // direction missing
+     ");\n"
+     "endmodule\n"},
+    {"module t;\n"
+     "    input bit i_bit;\n"
+     "input   byte  i_byte ;\n"
+     "input chandle i_chandle;\n"
+     "input event i_event;\n"
+     "input int i_int;\n"
+     "input integer i_inte;\n"
+     "input longint i_longint;\n"
+     "input real i_real;\n"
+     "input realtime i_realtime;\n"
+     "input shortint i_shortint;\n"
+     "input shortreal i_shortreal;\n"
+     "input string i_string;\n"
+     "input time i_time;\n"
+     "     output bit o_bit;\n"
+     "output    byte   o_byte  ;  \n"
+     "output chandle o_chandle;\n"
+     "output event o_event;\n"
+     "output int o_int;\n"
+     "output integer o_inte;\n"
+     "output longint o_longint;\n"
+     "output real o_real;\n"
+     "output realtime o_realtime;\n"
+     "output shortint o_shortint;\n"
+     "output shortreal o_shortreal;\n"
+     "output string o_string;\n"
+     "output time o_time;\n"
+     "endmodule\n",
+     "module t;\n"
+     "  input bit i_bit;\n"
+     "  input byte i_byte;\n"
+     "  input chandle i_chandle;\n"
+     "  input event i_event;\n"
+     "  input int i_int;\n"
+     "  input integer i_inte;\n"
+     "  input longint i_longint;\n"
+     "  input real i_real;\n"
+     "  input realtime i_realtime;\n"
+     "  input shortint i_shortint;\n"
+     "  input shortreal i_shortreal;\n"
+     "  input string i_string;\n"
+     "  input time i_time;\n"
+     "  output bit o_bit;\n"
+     "  output byte o_byte;\n"
+     "  output chandle o_chandle;\n"
+     "  output event o_event;\n"
+     "  output int o_int;\n"
+     "  output integer o_inte;\n"
+     "  output longint o_longint;\n"
+     "  output real o_real;\n"
+     "  output realtime o_realtime;\n"
+     "  output shortint o_shortint;\n"
+     "  output shortreal o_shortreal;\n"
+     "  output string o_string;\n"
+     "  output time o_time;\n"
+     "endmodule\n"},
+    {"module t (\n"
+     "    input bit i_bit,\n"
+     "input     byte   i_byte  ,\n"
+     "input chandle i_chandle,\n"
+     "input event i_event,\n"
+     "input int i_int,\n"
+     "input integer i_inte,\n"
+     "input longint i_longint,\n"
+     "input real i_real,\n"
+     "input realtime i_realtime,\n"
+     "input shortint i_shortint,\n"
+     "input shortreal i_shortreal,\n"
+     "input string i_string,\n"
+     "input time i_time,\n"
+     "    output bit o_bit,\n"
+     "output     byte   o_byte  ,  \n"
+     "output chandle o_chandle,\n"
+     "output event o_event,\n"
+     "output int o_int,\n"
+     "output integer o_inte,\n"
+     "output longint o_longint,\n"
+     "output real o_real,\n"
+     "output realtime o_realtime,\n"
+     "output shortint o_shortint,\n"
+     "output shortreal o_shortreal,\n"
+     "output string o_string,\n"
+     "output time o_time);\n"
+     "endmodule\n",
+     "module t (\n"
+     "    input  bit       i_bit,\n"
+     "    input  byte      i_byte,\n"
+     "    input  chandle   i_chandle,\n"
+     "    input  event     i_event,\n"
+     "    input  int       i_int,\n"
+     "    input  integer   i_inte,\n"
+     "    input  longint   i_longint,\n"
+     "    input  real      i_real,\n"
+     "    input  realtime  i_realtime,\n"
+     "    input  shortint  i_shortint,\n"
+     "    input  shortreal i_shortreal,\n"
+     "    input  string    i_string,\n"
+     "    input  time      i_time,\n"
+     "    output bit       o_bit,\n"
+     "    output byte      o_byte,\n"
+     "    output chandle   o_chandle,\n"
+     "    output event     o_event,\n"
+     "    output int       o_int,\n"
+     "    output integer   o_inte,\n"
+     "    output longint   o_longint,\n"
+     "    output real      o_real,\n"
+     "    output realtime  o_realtime,\n"
+     "    output shortint  o_shortint,\n"
+     "    output shortreal o_shortreal,\n"
+     "    output string    o_string,\n"
+     "    output time      o_time\n"
+     ");\n"
+     "endmodule\n"},
+    {"module m;foo bar(.baz({larry, moe, curly}));endmodule",
+     "module m;\n"
+     "  foo bar (.baz({larry, moe, curly}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.baz({larry,// expand this\n"
+     "moe, curly}));endmodule",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .baz({\n"
+     "        larry,  // expand this\n"
+     "        moe,\n"
+     "        curly\n"
+     "      })\n"
+     "  );\n"
+     "endmodule\n"},
+    {"parameter priv_reg_t impl_csr[] = {\n"
+     "// Machine mode mode CSR\n"
+     "MVENDORID, //\n"
+     "MARCHID,   //\n"
+     "DSCRATCH0, //\n"
+     "DSCRATCH1  //\n"
+     "};",
+     "parameter priv_reg_t impl_csr[] = {\n"
+     "  // Machine mode mode CSR\n"
+     "  MVENDORID,  //\n"
+     "  MARCHID,  //\n"
+     "  DSCRATCH0,  //\n"
+     "  DSCRATCH1  //\n"
+     "};\n"},
+    {"parameter priv_reg_t impl_csr[] = {\n"
+     "// Expand elements\n"
+     "MVENDORID,\n"
+     "MARCHID,\n"
+     "DSCRATCH0,\n"
+     "DSCRATCH1\n"
+     "};",
+     "parameter priv_reg_t impl_csr[] = {\n"
+     "  // Expand elements\n"
+     "  MVENDORID,\n"
+     "  MARCHID,\n"
+     "  DSCRATCH0,\n"
+     "  DSCRATCH1\n"
+     "};\n"},
+    /* TODO(b/158131099): to fix these, reinterpret 'b' as a kPortDeclaration
+    {"module somefunction ("
+     "input logic clk, input a, b);endmodule",
+     "module somefunction (\n"
+     "    input logic clk,\n"
+     "    input       a,\n"  // type missing
+     "                b\n"  // type and direction missing
+     ");\n"
+     "endmodule\n"},
+    {"module somefunction ("
+     "input logic clk, int a, b);endmodule",
+     "module somefunction (\n"
+     "    input logic clk,\n"
+     "          int   a,\n"  // direction missing
+     "                b\n"  // type and direction missing
+     ");\n"
+     "endmodule\n"},
+     */
+    {"module foo(\n"
+     "//c1\n"
+     "input wire x , \n"
+     "//c2\n"
+     "output reg  yy\n"
+     "//c3\n"
+     ") ;endmodule:foo\n",
+     "module foo (\n"
+     "    //c1\n"
+     "    input  wire x,\n"  // aligned, ignoring comments
+     "    //c2\n"
+     "    output reg  yy\n"
+     "    //c3\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(\n"
+     "//c1\n"
+     "input wire x , \n"
+     "//c2a\n"  // longer comment
+     "//c2b\n"
+     "output reg  yy\n"
+     "//c3\n"
+     ") ;endmodule:foo\n",
+     "module foo (\n"
+     "    //c1\n"
+     "    input  wire x,\n"  // aligned, ignoring comments
+     "    //c2a\n"           // note: separated by 2 lines of comments
+     "    //c2b\n"
+     "    output reg  yy\n"
+     "    //c3\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(\n"
+     "`ifdef   FOO\n"
+     "input wire x , \n"
+     " `else\n"
+     "output reg  yy\n"
+     " `endif\n"
+     ") ;endmodule:foo\n",
+     "module foo (\n"
+     "`ifdef FOO\n"
+     "    input  wire x,\n"  // aligned, ignoring preprocessor conditionals
+     "`else\n"
+     "    output reg  yy\n"
+     "`endif\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(\n"
+     "input w , \n"
+     "`define   FOO BAR\n"
+     "input wire x , \n"
+     " `include  \"stuff.svh\"\n"
+     "output reg  yy\n"
+     " `undef    FOO\n"
+     "output zz\n"
+     ") ;endmodule:foo\n",
+     "module foo (\n"
+     "    input       w,\n"  // aligned, ignoring preprocessor directives
+     "    `define FOO BAR\n"
+     "    input  wire x,\n"
+     "    `include \"stuff.svh\"\n"
+     "    output reg  yy\n"
+     "    `undef FOO\n"
+     "    output      zz\n"  // aligned, ignoring preprocessor directives
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(\n"
+     "input wire x , \n  \n"  // blank line, separating alignment groups
+     "output reg  yy\n"
+     ") ;endmodule:foo\n",
+     "module foo (\n"
+     "    input wire x,\n"  // not aligned, due to blank line separating groups
+     "\n"
+     "    output reg yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(\n"
+     "input wire x1 [r:s],\n"
+     "input [p:q] x2 , \n  \n"  // blank line, separating alignment groups
+     "output reg  [jj:kk]yy1,\n"
+     "output pkg::barr_t [mm:nn] yy2\n"
+     ") ;endmodule:foo\n",
+     "module foo (\n"
+     "    input wire       x1[r:s],\n"  // aligned in this group, but not across
+                                        // groups
+     "    input      [p:q] x2,\n"
+     "\n"
+     "    output reg         [jj:kk] yy1,\n"
+     "    output pkg::barr_t [mm:nn] yy2\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo(\n"  // same as previous, with comments
+     " //c1\n"
+     "input wire x1 [r:s],\n"
+     "input [p:q] x2 , \n"
+     " //c2\n\n"  // blank line, separating alignment groups
+     " //c3\n"
+     "output reg  [jj:kk]yy1,\n"
+     " //c4\n"
+     "output pkg::barr_t [mm:nn] yy2\n"
+     ") ;endmodule:foo\n",
+     "module foo (\n"
+     "    //c1\n"
+     "    input wire       x1[r:s],\n"  // aligned in this group, but not across
+                                        // groups
+     "    input      [p:q] x2,\n"
+     "    //c2\n"
+     "\n"
+     "    //c3\n"
+     "    output reg         [jj:kk] yy1,\n"
+     "    //c4\n"
+     "    output pkg::barr_t [mm:nn] yy2\n"
+     ");\n"
+     "endmodule : foo\n"},
+
+    {// align null-statement (issue #824)
+     "class sample;"
+     "bit a;;"
+     "bit b;"
+     "endclass",
+     "class sample;\n"
+     "  bit a;\n"
+     "  ;\n"
+     "  bit b;\n"
+     "endclass\n"},
+    {"class sample;"
+     "bit a;;"
+     "endclass",
+     "class sample;\n"
+     "  bit a;\n"
+     "  ;\n"
+     "endclass\n"},
+    {"class sample;"
+     "bit a;"
+     "bit b;;"
+     "endclass",
+     "class sample;\n"
+     "  bit a;\n"
+     "  bit b;\n"
+     "  ;\n"
+     "endclass\n"},
+
+    {// aligning here just barely fits in the 40col limit
+     "module foo(  input int signed x [a:b],"
+     "output reg [mm:nn] yy) ;endmodule:foo\n",
+     "module foo (\n"
+     // ---------------40col----------------->
+     "    input  int signed         x [a:b],\n"  // aligned, still fits
+     "    output reg        [mm:nn] yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {// when aligning would result in exceeding column limit, don't align for
+     // now
+     "module foo(  input int signed x [aa:bb],"
+     "output reg [mm:nn] yy) ;endmodule:foo\n",
+     "module foo (\n"
+     // ---------------40col----------------->
+     //   input  int signed         x [aa:bb],\n"
+     //   output reg        [mm:nn] yy\n"
+     "    input  int signed         x [aa:bb],\n"  // aligned, still fits
+     "    output reg        [mm:nn] yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {// when aligning would result in exceeding column limit, don't align for
+     // now
+     "module foo(  input int signed x [aa:bb],"
+     "output reg [mm:nn] yyy) ;endmodule:foo\n",
+     "module foo (\n"
+     // ---------------40col----------------->
+     //   input  int signed         x  [aa:bb],\n"  // over limit, by comma
+     //   output reg        [mm:nn] yyy\n"
+     "    input int signed x[aa:bb],\n"  // aligned would be 41 columns
+     "    output reg [mm:nn] yyy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {// when aligning would result in exceeding column limit, don't align for
+     // now
+     "module foo(  input int signed x [a:b],//c\n"
+     "output reg [m:n] yy) ;endmodule:foo\n",
+     "module foo (\n"
+     // ---------------40col---------------->
+     //   input  int signed       x [a:b],  //c\n"  // over limit, by comment
+     //   output reg        [m:n] yy\n"
+     "    input int signed x[a:b],  //c\n"  // aligned would be 42 columns
+     "    output reg [m:n] yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {// aligning interfaces in port headers like types
+     // TODO(b/161181877): flush interface port type left (multi-column)
+     "module foo(  input clk , inter.face yy) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input            clk,\n"  // aligned
+     "          inter.face yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {// aligning interfaces in port headers like types
+     // TODO(b/161181877): flush interface port type left (multi-column)
+     "module foo(  input wire   clk , inter.face yy) ;endmodule:foo\n",
+     "module foo (\n"
+     "    input wire       clk,\n"  // aligned
+     "          inter.face yy\n"
+     ");\n"
+     "endmodule : foo\n"},
+
+    // module local variable/net declaration alignment test cases
+    {"module m;\n"
+     "logic a;\n"
+     "bit b;\n"
+     "endmodule\n",
+     "module m;\n"
+     "  logic a;\n"
+     "  bit   b;\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "logic a;\n"
+     "bit b;\n"
+     "initial e=f;\n"  // separates alignment groups
+     "wire c;\n"
+     "bit d;\n"
+     "endmodule\n",
+     "module m;\n"
+     "  logic a;\n"
+     "  bit   b;\n"
+     "  initial e = f;\n"  // separates alignment groups
+     "  wire c;\n"
+     "  bit  d;\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "// hello a\n"
+     "logic a;\n"
+     "// hello b\n"
+     "bit b;\n"
+     "endmodule\n",
+     "module m;\n"
+     "  // hello a\n"
+     "  logic a;\n"
+     "  // hello b\n"
+     "  bit   b;\n"  // aligned across comments
+     "endmodule\n"},
+    {"module m;\n"
+     "// hello a\n"
+     "logic a;\n"
+     "\n"  // extra blank line
+     "// hello b\n"
+     "bit b;\n"
+     "endmodule\n",
+     "module m;\n"
+     "  // hello a\n"
+     "  logic a;\n"
+     "\n"              // extra blank line
+     "  // hello b\n"  // aligned across blank lines
+     "  bit   b;\n"    // aligned across comments
+     "endmodule\n"},
+    {"module m;\n"
+     "logic [x:y]a;\n"  // packed dimensions
+     "bit b;\n"
+     "endmodule\n",
+     "module m;\n"
+     "  logic [x:y] a;\n"
+     "  bit         b;\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "logic a;\n"
+     "bit [pp:qq]b;\n"  // packed dimensions
+     "endmodule\n",
+     "module m;\n"
+     "  logic         a;\n"
+     "  bit   [pp:qq] b;\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "logic [x:y]a;\n"  // packed dimensions
+     "bit [pp:qq]b;\n"  // packed dimensions
+     "endmodule\n",
+     "module m;\n"
+     "  logic [  x:y] a;\n"
+     "  bit   [pp:qq] b;\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "logic [x:y]a;\n"         // packed dimensions
+     "wire [pp:qq] [e:f]b;\n"  // packed dimensions, 2D
+     "endmodule\n",
+     "module m;\n"
+     "  logic [  x:y]      a;\n"
+     "  wire  [pp:qq][e:f] b;\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "logic a [x:y];\n"  // unpacked dimensions
+     "bit bbb;\n"
+     "endmodule\n",
+     "module m;\n"
+     "  logic a   [x:y];\n"
+     "  bit   bbb;\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "logic aaa ;\n"
+     "wire w [yy:zz];\n"  // unpacked dimensions
+     "endmodule\n",
+     "module m;\n"
+     "  logic aaa;\n"
+     "  wire  w   [yy:zz];\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "logic aaa [s:t] ;\n"  // unpacked dimensions
+     "wire w [yy:zz];\n"    // unpacked dimensions
+     "endmodule\n",
+     "module m;\n"
+     "  logic aaa[  s:t];\n"
+     "  wire  w  [yy:zz];\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "logic aaa [s:t] ;\n"     // unpacked dimensions
+     "wire w [yy:zz][u:v];\n"  // unpacked dimensions, 2D
+     "endmodule\n",
+     "module m;\n"
+     "  logic aaa[  s:t];\n"
+     "  wire  w  [yy:zz] [u:v];\n"
+     // TODO(b/165323560): unwanted space between unpacked dimensions of 'w'
+     "endmodule\n"},
+    {"module m;\n"
+     "qqq::rrr s;\n"     // user-defined type
+     "wire [pp:qq]w;\n"  // packed dimensions
+     "endmodule\n",
+     "module m;\n"
+     "  qqq::rrr         s;\n"
+     "  wire     [pp:qq] w;\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "qqq#(rr) s;\n"     // parameterized type
+     "wire [pp:qq]w;\n"  // packed dimensions
+     "endmodule\n",
+     "module m;\n"
+     "  qqq #(rr)         s;\n"
+     "  wire      [pp:qq] w;\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "logic a;\n"
+     "bit b;\n"
+     "my_module  my_inst( );\n"  // module instance separates alignment groups
+     "wire c;\n"
+     "bit d;\n"
+     "endmodule\n",
+     "module m;\n"
+     "  logic a;\n"  // these two are aligned
+     "  bit   b;\n"
+     "  my_module my_inst ();\n"  // module instance separates alignment groups
+     "  wire c;\n"                // these two are aligned
+     "  bit  d;\n"
+     "endmodule\n"},
+    {"module m;\n"
+     "logic aaa = expr1;\n"
+     "bit b = expr2;\n"
+     "endmodule\n",
+     "module m;\n"
+     "  logic aaa = expr1;\n"
+     "  bit   b = expr2;\n"  // no alignment at '=' yet
+     "endmodule\n"},
+    {"(* foo='{\"bar_.*\"} *)\n"  // funny attribute
+     "module mattr;\n"
+     "(* attr1=\"value1\" *)\n"  // attribute ignored
+     "ex_input_pins_t ex_input_pins;\n"
+     "(* attr2=\"value2\" *)\n"  // attribute ignored
+     "ex_output_pins_t ex_output_pins;\n"
+     "(* attr3=\"value3\" *)\n"  // attribute ignored
+     "ex wrap_ex ( );\n"
+     "endmodule\n",
+     "(* foo='{\"bar_.*\"} *)\n"
+     "module mattr;\n"
+     "  (* attr1=\"value1\" *)\n"           // indented
+     "  ex_input_pins_t  ex_input_pins;\n"  // aligned
+     "  (* attr2=\"value2\" *)\n"           // indented
+     "  ex_output_pins_t ex_output_pins;\n"
+     "  (* attr3=\"value3\" *)\n"  // indented
+     "  ex wrap_ex ();\n"
+     "endmodule\n"},
+    {"module mattr;\n"
+     "ex_input_pins_t ex_input_pins;\n"
+     "ex_output_pins_t ex_output_pins;\n"
+     "(* package_definition=\"ex_pkg\" *)\n"  // attribute ignored
+     "ex wrap_ex (\n"
+     ".clk(ex_input_pins.clk),\n"
+     ".rst(ex_input_pins.rst),\n"
+     ".in(ex_input_pins.in)\n"
+     ");\n"
+     "endmodule\n",
+     "module mattr;\n"
+     "  ex_input_pins_t  ex_input_pins;\n"  // aligned
+     "  ex_output_pins_t ex_output_pins;\n"
+     "  (* package_definition=\"ex_pkg\" *)\n"  // indented
+     "  ex wrap_ex (\n"
+     "      .clk(ex_input_pins.clk),\n"
+     "      .rst(ex_input_pins.rst),\n"
+     "      .in (ex_input_pins.in)\n"  // aligned
+     "  );\n"
+     "endmodule\n"},
+    {"module test;\n"
+     "bind entropy_src tlul_assert #(.EndpointType(\"Device\"))\n"
+     "tlul_assert_device (.clk_i, .rst_ni, .h2d(tl_i), .d2h(tl_o));\n"
+     "endmodule\n",
+     "module test;\n"
+     "  bind entropy_src tlul_assert #(\n"
+     "      .EndpointType(\"Device\")\n"
+     "  ) tlul_assert_device (\n"
+     "      .clk_i,\n"
+     "      .rst_ni,\n"
+     "      .h2d(tl_i),\n"
+     "      .d2h(tl_o)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"module test;\n"
+     "bind entropy_src tlul_assert #(.EndpointType(\"Device\"))\n"
+     "tlul_assert_device (.clk_i, .rst_ni,\n\n .h2d(tl_i),\n\n .d2h(tl_o));\n"
+     "endmodule\n",
+     "module test;\n"
+     "  bind entropy_src tlul_assert #(\n"
+     "      .EndpointType(\"Device\")\n"
+     "  ) tlul_assert_device (\n"
+     "      .clk_i,\n"
+     "      .rst_ni,\n"
+     "\n"
+     "      .h2d(tl_i),\n"
+     "\n"
+     "      .d2h(tl_o)\n"
+     "  );\n"
+     "endmodule\n"},
+    {"bind expand_me long_name #(.W(W_CONST), .D(D_CONST)) instaaance_name ("
+     ".in(iiiiiiiin),\n\n .out(ooooooout),\n .clk(ccccccclk),\n\n"
+     ".in1234 (in),\n //c1\n .out1234(out),\n .clk1234(clk),);",
+     "bind expand_me long_name #(\n"
+     "    .W(W_CONST),\n"
+     "    .D(D_CONST)\n"
+     ") instaaance_name (\n"
+     "    .in(iiiiiiiin),\n"
+     "\n"
+     "    .out(ooooooout),\n"
+     "    .clk(ccccccclk),\n"
+     "\n"
+     "    .in1234 (in),\n"
+     "    //c1\n"
+     "    .out1234(out),\n"
+     "    .clk1234(clk),\n"
+     ");\n"},
+    {"initial // clock generation\n begin\n clk = 0;\n forever begin\n"
+     "#4ns clk = !clk;\n end\n end\n",
+     "initial  // clock generation\n"
+     "  begin\n"
+     "    clk = 0;\n"
+     "    forever begin\n"
+     "      #4ns clk = !clk;\n"
+     "    end\n"
+     "  end\n"},
+    {"module foo #(int x,int y) ;endmodule:foo\n",  // parameters
+     "module foo #(\n"
+     "    int x,\n"
+     "    int y\n"
+     ");\n"  // each parameter on its own line
+     "endmodule : foo\n"},
+    {"module foo #(int x)(input y) ;endmodule:foo\n",
+     // parameter and port
+     "module foo #(\n"
+     "    int x\n"
+     ") (\n"
+     "    input y\n"
+     ");\n"  // each paramater and port item should be on its own line
+     "endmodule : foo\n"},
+    {"module foo #(parameter int x,parameter int y) ;endmodule:foo\n",
+     // parameters don't fit (also should be on its own line)
+     "module foo #(\n"
+     "    parameter int x,\n"
+     "    parameter int y\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo #(parameter int xxxx,parameter int yyyy) ;endmodule:foo\n",
+     // parameters don't fit
+     "module foo #(\n"
+     "    parameter int xxxx,\n"
+     "    parameter int yyyy\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo #(parameter int x = $clog2  (N) ,parameter int y ) "
+     ";endmodule:foo\n",
+     // parameters don't fit
+     "module foo #(\n"
+     "    parameter int x = $clog2(N),\n"  // no space after $clog2
+     "    parameter int y\n"
+     ");\n"
+     "endmodule : foo\n"},
+    {"module foo #(//comment\n"
+     "parameter bar =1,\n"
+     "localparam baz =2"
+     ") ();"
+     "endmodule",
+     "module foo #(  //comment\n"
+     "    parameter  bar = 1,\n"
+     "    localparam baz = 2\n"
+     ") ();\n"
+     "endmodule\n"},
+    {"module foo #("
+     "parameter  bar =1,//comment\n"
+     "localparam baz =2"
+     ") ();"
+     "endmodule",
+     "module foo #(\n"
+     "    parameter  bar = 1,  //comment\n"
+     "    localparam baz = 2\n"
+     ") ();\n"
+     "endmodule\n"},
+    {"module foo #("
+     "parameter  bar =1,"
+     "localparam baz =2//comment\n"
+     ") ();"
+     "endmodule",
+     "module foo #(\n"
+     "    parameter  bar = 1,\n"
+     "    localparam baz = 2   //comment\n"
+     ") ();\n"
+     "endmodule\n"},
+    {"module foo #("
+     "parameter  bar =1//comment\n"
+     ",localparam baz =2\n"
+     ") ();"
+     "endmodule",
+     "module foo #(\n"
+     "      parameter  bar = 1  //comment\n"
+     "    , localparam baz = 2\n"
+     ") ();\n"
+     "endmodule\n"},
+    {"module foo;"
+     // fit in one line
+     "parameter int i = '{\n"
+     "1,\n"
+     "2,\n"
+     "3\n"
+     "};\n"
+     "endmodule",
+     "module foo;\n"
+     "  parameter int i = '{1, 2, 3};\n"
+     "endmodule\n"},
+    {"module foo;"
+     // too long for one line, expand
+     "localparam logic [63:0] RC[24] = '{\n"
+     "64'h 1,\n"
+     "64'h 2,\n"
+     "64'h 3\n"
+     "};\n"
+     "endmodule",
+     "module foo;\n"
+     "  localparam logic [63:0] RC[24] = '{\n"
+     "      64'h1,\n"
+     "      64'h2,\n"
+     "      64'h3\n"
+     "  };\n"
+     "endmodule\n"},
+    {"module foo;"
+     "parameter int i = '{\n"
+     // force expansion
+     "1, //\n"
+     "2,\n"
+     "3\n"
+     "};\n"
+     "endmodule",
+     "module foo;\n"
+     "  parameter int i = '{\n"
+     "      1,  //\n"
+     "      2,\n"
+     "      3\n"
+     "  };\n"
+     "endmodule\n"},
+    {"module foo;"
+     "localparam logic [63:0] RC[24] = '{\n"
+     "64'h 0000_0000_0000_0001, // 0\n"
+     "64'h 0000_0000_0000_8082, // 1\n"
+     "64'h 8000_0000_8000_8008 // 23\n"
+     "};\n"
+     "endmodule",
+     "module foo;\n"
+     "  localparam logic [63:0] RC[24] = '{\n"
+     "      64'h0000_0000_0000_0001,  // 0\n"
+     "      64'h0000_0000_0000_8082,  // 1\n"
+     "      64'h8000_0000_8000_8008  // 23\n"
+     "  };\n"
+     "endmodule\n"},
+    {"module foo;"
+     // nest two patterns
+     "parameter logic [11:0] i = '{\n"
+     "'{1,2,3},\n"
+     "'{1,2,3}\n"
+     "};\n"
+     "endmodule",
+     "module foo;\n"
+     "  parameter logic [11:0] i = '{\n"
+     "      '{1, 2, 3},\n"
+     "      '{1, 2, 3}\n"
+     "  };\n"
+     "endmodule\n"},
+    {"module foo;"
+     // nest two patterns, expand interior
+     "parameter logic [11:0] i = '{\n"
+     "'{1, //\n"
+     " 2,3},\n"
+     "'{1,2,3}\n"
+     "};\n"
+     "endmodule",
+     "module foo;\n"
+     "  parameter logic [11:0] i = '{\n"
+     "      '{\n"
+     "          1,  //\n"
+     "          2,\n"
+     "          3\n"
+     "      },\n"
+     "      '{1, 2, 3}\n"
+     "  };\n"
+     "endmodule\n"},
+    {"module foo;"
+     // nest two patterns, expand both
+     "parameter nest [2] i = '{\n"
+     "'{first : 32'h0000_0001,\n"
+     "  second : 32'h0000_0011,\n"
+     "  third: 32'h0000_0111},\n"
+     "'{first : 32'h1000_0001,\n"
+     "  second : 32'h1000_0011,\n"
+     "  third: 32'h1000_0111}\n"
+     "};\n"
+     "endmodule",
+     "module foo;\n"
+     "  parameter nest [2] i = '{\n"
+     "      '{\n"
+     "          first : 32'h0000_0001,\n"
+     "          second : 32'h0000_0011,\n"
+     "          third: 32'h0000_0111\n"
+     "      },\n"
+     "      '{\n"
+     "          first : 32'h1000_0001,\n"
+     "          second : 32'h1000_0011,\n"
+     "          third: 32'h1000_0111\n"
+     "      }\n"
+     "  };\n"
+     "endmodule\n"},
+    {"module foo;"
+     // nest three patterns
+     "parameter logic [11:0] i = '{\n"
+     "'{'{1,2,3},4}\n"
+     "};\n"
+     "endmodule",
+     "module foo;\n"
+     "  parameter logic [11:0] i = '{\n"
+     "      '{'{1, 2, 3}, 4}\n"
+     "  };\n"
+     "endmodule\n"},
+    {"module foo;"
+     // nest three patterns, expand interior
+     "parameter logic [11:0] i = '{\n"
+     "'{\n"
+     "'{first : 32'h0000_0001,\n"
+     "  second : 32'h0000_0011,\n"
+     "  third: 32'h0000_0111},\n"
+     "  4},\n"
+     "  5,\n"
+     "  '{1,2,3}\n"
+     "};\n"
+     "endmodule",
+     "module foo;\n"
+     "  parameter logic [11:0] i = '{\n"
+     "      '{\n"
+     "          '{\n"
+     "              first : 32'h0000_0001,\n"
+     "              second : 32'h0000_0011,\n"
+     "              third: 32'h0000_0111\n"
+     "          },\n"
+     "          4\n"
+     "      },\n"
+     "      5,\n"
+     "      '{1, 2, 3}\n"
+     "  };\n"
+     "endmodule\n"},
+    {"module    top;"
+     "foo#(  \"test\"  ) foo(  );"
+     "bar#(  \"test\"  ,5) bar(  );"
+     "endmodule\n",
+     "module top;\n"
+     "  foo #(\"test\") foo ();\n"  // module instantiation, string arg
+     "  bar #(\"test\", 5) bar ();\n"
+     "endmodule\n"},
+    {"module    top;"
+     "foo#(  `\"test`\"  ) foo(  );"
+     "bar#(  `\"test`\"  ,5) bar(  );"
+     "endmodule\n",
+     "module top;\n"
+     "  foo #(`\"test`\") foo ();\n"  // module instantiation, eval string arg
+     "  bar #(`\"test`\", 5) bar ();\n"
+     "endmodule\n"},
+    {"`ifdef FOO\n"
+     "  module bar;endmodule\n"
+     "`endif\n",
+     "`ifdef FOO\n"
+     "module bar;\n"
+     "endmodule\n"
+     "`endif\n"},
+    {"`ifdef FOO\n"
+     "  module bar;endmodule\n"
+     "`else module baz;endmodule\n"
+     "`endif\n",
+     "`ifdef FOO\n"
+     "module bar;\n"
+     "endmodule\n"
+     "`else\n"
+     "module baz;\n"
+     "endmodule\n"
+     "`endif\n"},
+    {"`ifdef FOO\n"
+     "  module bar;endmodule\n"
+     "`else /* glue me */ module baz;endmodule\n"
+     "`endif\n",
+     "`ifdef FOO\n"
+     "module bar;\n"
+     "endmodule\n"
+     "`else  /* glue me */\n"
+     "module baz;\n"
+     "endmodule\n"
+     "`endif\n"},
+    {"`ifdef FOO\n"
+     "  module bar;endmodule\n"
+     "`else// different unit\n"
+     "  module baz;endmodule\n"
+     "`endif\n",
+     "`ifdef FOO\n"
+     "module bar;\n"
+     "endmodule\n"
+     "`else  // different unit\n"
+     "module baz;\n"
+     "endmodule\n"
+     "`endif\n"},
+
+    // unary: + - !  ~ & | ^  ~& ~| ~^ ^~
+    {"module m;foo bar(.x(-{a,b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x(-{a, b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(!{a,b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x(!{a, b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(~{a,b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x(~{a, b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(&{a,b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x(&{a, b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(|{a,b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x(|{a, b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(^{a,b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x(^{a, b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(~&{a,b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x(~&{a, b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(~|{a,b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x(~|{a, b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(~^{a,b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x(~^{a, b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(^~{a,b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x(^~{a, b}));\n"
+     "endmodule\n"},
+
+    // binary: + - * / % & | ^ ^~ ~^ && ||
+    {"module m;foo bar(.x(a+b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a + b));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a-b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a - b));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a*b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a * b));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a/b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a / b));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a%b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a % b));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a&b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a & b));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a|b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a | b));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a^b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a ^ b));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a^~b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a ^~ b));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a~^b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a ~^ b));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a&&b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a && b));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a||b));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a || b));\n"
+     "endmodule\n"},
+
+    // {a} op {b}
+    {"module m;foo bar(.x({a}+{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} + {b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x({a}-{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} - {b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x({a}*{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} * {b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x({a}/{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} / {b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x({a}%{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} % {b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x({a}&{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} & {b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x({a}|{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} | {b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x({a}^{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} ^ {b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x({a}^~{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} ^~ {b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x({a}~^{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} ~^ {b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x({a}&&{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} && {b}));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x({a}||{b}));endmodule",
+     "module m;\n"
+     "  foo bar (.x({a} || {b}));\n"
+     "endmodule\n"},
+
+    // (a) op (b)
+    {"module m;foo bar(.x((a)+(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) + (b)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a)-(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) - (b)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a)*(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) * (b)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a)/(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) / (b)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a)%(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) % (b)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a)&(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) & (b)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a)|(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) | (b)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a)^(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) ^ (b)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a)^~(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) ^~ (b)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a)~^(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) ~^ (b)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a)&&(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) && (b)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a)||(b)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a) || (b)));\n"
+     "endmodule\n"},
+
+    // a[b] op c
+    {"module m;foo bar(.x(a[b]+c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] + c));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b]-c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] - c));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b]*c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] * c));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b]/c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] / c));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b]%c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] % c));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b]&c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] & c));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b]|c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] | c));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b]^c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] ^ c));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b]^~c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] ^~ c));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b]~^c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] ~^ c));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b]&&c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] && c));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b]||c));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] || c));\n"
+     "endmodule\n"},
+
+    // misc
+    {"module m;foo bar(.x(a[1:0]^b[2:1]));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[1:0] ^ b[2:1]));\n"
+     "endmodule\n"},
+
+    {"module m;foo bar(.x(a[b] | b[c]));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] | b[c]));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x(a[b] & b[c]));endmodule",
+     "module m;\n"
+     "  foo bar (.x(a[b] & b[c]));\n"
+     "endmodule\n"},
+
+    {"module m;foo bar(.x((a^c)^(b^ ~c)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a ^ c) ^ (b ^ ~c)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a^c)^(b^~c)));endmodule",
+     "module m;\n"
+     "  foo bar (.x((a ^ c) ^ (b ^~ c)));\n"
+     "endmodule\n"},
+    {"module m;foo bar(.x((a^{c,d})^(b^^{c,d})));endmodule",
+     "module m;\n"
+     "  foo bar (\n"
+     "      .x((a ^ {c, d}) ^ (b ^ ^{c, d}))\n"
+     "  );\n"
+     "endmodule\n"},
+
+    {// module items mixed with preprocessor conditionals and comments
+     "    module foo;\n"
+     "// comment1\n"
+     "  `ifdef SIM\n"
+     "// comment2\n"
+     " `elsif SYN\n"
+     " // comment3\n"
+     "       `else\n"
+     "// comment4\n"
+     " `endif\n"
+     "// comment5\n"
+     "  endmodule",
+     "module foo;\n"
+     "  // comment1\n"
+     "`ifdef SIM\n"
+     "  // comment2\n"
+     "`elsif SYN\n"
+     "  // comment3\n"
+     "`else\n"
+     "  // comment4\n"
+     "`endif\n"
+     "  // comment5\n"
+     "endmodule\n"},
+    {"  module bar;wire foo;reg bear;endmodule\n",
+     "module bar;\n"
+     "  wire foo;\n"
+     "  reg  bear;\n"  // aligned
+     "endmodule\n"},
+    {" module bar;initial\nbegin a<=b . c ; end endmodule\n",
+     "module bar;\n"
+     "  initial begin\n"
+     "    a <= b.c;\n"
+     "  end\n"
+     "endmodule\n"},
+    {"module foo ();\nif (1) begin\n$finish(\n"
+     "      1    ); $finish    ();\n  end\nendmodule",
+     "module foo ();\n"
+     "  if (1) begin\n"
+     "    $finish(1);\n"
+     "    $finish();\n"
+     "  end\n"
+     "endmodule\n"},
+    {"  module bar;for(genvar i = 0 ; i<N ; ++ i  ) begin end endmodule\n",
+     "module bar;\n"
+     "  for (genvar i = 0; i < N; ++i) begin\n"
+     "  end\n"
+     "endmodule\n"},
+    {"  module bar;for(genvar i = 0 ; i!=N ; i ++  ) begin "
+     "foo f;end endmodule\n",
+     "module bar;\n"
+     "  for (genvar i = 0; i != N; i++) begin\n"
+     "    foo f;\n"
+     "  end\n"
+     "endmodule\n"},
+    {
+        "module block_generate;\n"
+        "`ASSERT(blah)\n"
+        "generate endgenerate endmodule\n",
+        "module block_generate;\n"
+        "  `ASSERT(blah)\n"
+        "  generate\n"
+        "  endgenerate\n"
+        "endmodule\n",
+    },
+    {
+        "module conditional_generate;\n"
+        "if(foo)  ; \t"  // null action
+        "endmodule\n",
+        "module conditional_generate;\n"
+        "  if (foo);\n"
+        "endmodule\n",
+    },
+    {
+        "module conditional_generate;\n"
+        "if(foo[a*b+c])  ; \t"  // null action
+        "endmodule\n",
+        "module conditional_generate;\n"
+        "  if (foo[a*b+c]);\n"  // allow compact expressions inside []
+        "endmodule\n",
+    },
+    {
+        "module conditional_generate;\n"
+        "if(foo)begin\n"
+        "`ASSERT()\n"
+        "`COVER()\n"
+        " end\n"
+        "endmodule\n",
+        "module conditional_generate;\n"
+        "  if (foo) begin\n"
+        "    `ASSERT()\n"
+        "    `COVER()\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module conditional_generate;\n"
+        "`ASSERT()\n"
+        "if(foo)begin\n"
+        " end\n"
+        "`COVER()\n"
+        "endmodule\n",
+        "module conditional_generate;\n"
+        "  `ASSERT()\n"
+        "  if (foo) begin\n"
+        "  end\n"
+        "  `COVER()\n"
+        "endmodule\n",
+    },
+    {
+        "module conditional_generate;\n"
+        "if(foo)begin\n"
+        "           // comment1\n"
+        " // comment2\n"
+        " end\n"
+        "endmodule\n",
+        "module conditional_generate;\n"
+        "  if (foo) begin\n"
+        "    // comment1\n"
+        "    // comment2\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;"
+        "for(genvar i=0; ;)\n; "   // null generate statement
+        "for(genvar j=0 ;; )\n; "  // null generate statement
+        "endmodule",
+        "module m;\n"
+        "  for (genvar i = 0;;);\n"
+        "  for (genvar j = 0;;);\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;"
+        "for (genvar f = 0; f < N; f++) begin "
+        "assign x = y; assign y = z;"
+        "end endmodule",
+        "module m;\n"
+        "  for (genvar f = 0; f < N; f++) begin\n"
+        "    assign x = y;\n"
+        "    assign y = z;\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        // standalone genvar statement
+        "module m ;"
+        "genvar f;"
+        "for(f=0; f<N; f ++ )begin "
+        "end endmodule",
+        "module m;\n"
+        "  genvar f;\n"
+        "  for (f = 0; f < N; f++) begin\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        // multiple arguments to genvar statement
+        "module m ;"
+        "genvar f, g;"
+        "for(f=0; f<N; f ++ )begin "
+        "end for(g=N; g>0; g -- )begin "
+        "end endmodule",
+        "module m;\n"
+        "  genvar f, g;\n"
+        "  for (f = 0; f < N; f++) begin\n"
+        "  end\n"
+        "  for (g = N; g > 0; g--) begin\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        // multiple genvar statements
+        "module m ;"
+        "genvar f;"
+        "genvar g;"
+        "for(f=0; f<N; f ++ )begin "
+        "end for(g=N; g>0; g -- )begin "
+        "end endmodule",
+        "module m;\n"
+        "  genvar f;\n"
+        "  genvar g;\n"
+        "  for (f = 0; f < N; f++) begin\n"
+        "  end\n"
+        "  for (g = N; g > 0; g--) begin\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module event_control ;"
+        "always@ ( posedge   clk )z<=y;"
+        "endmodule\n",
+        "module event_control;\n"
+        "  always @(posedge clk) z <= y;\n"
+        "endmodule\n",
+    },
+    {
+        "module always_if ;"
+        "always@ ( posedge   clk ) if (expr) z<=y;"
+        "endmodule\n",
+        "module always_if;\n"
+        "  always @(posedge clk)\n"  // doesn't fit
+        "    if (expr)\n"
+        "      z <= y;\n"
+        "endmodule\n",
+    },
+    {
+        "module always_if ;"
+        "always@*  if (expr) z<=y;"
+        "endmodule\n",
+        "module always_if;\n"
+        "  always @* if (expr) z <= y;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else ;"
+        "always@*  if (expr) z<=y; else g<=0;"
+        "endmodule\n",
+        "module always_if_else;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"  // fits
+        "    else g <= 0;\n"       // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else_if ;"
+        "always@*  if (expr) z<=y; else if (w) g<=0;"
+        "endmodule\n",
+        "module always_if_else_if;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"    // fits
+        "    else if (w) g <= 0;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else_if_else ;"
+        "always@*  if (expr) z<=y; else if (w) g<=0;else h<=1;"
+        "endmodule\n",
+        "module always_if_else_if_else;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"    // fits
+        "    else if (w) g <= 0;\n"  // fits
+        "    else h <= 1;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(b,  c)"
+        "  for (;;)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(b, c) for (;;) s = y;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  for (i=0;i<k;++i)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    for (i = 0; i < k; ++i)\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  repeat (jj+kk)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    repeat (jj + kk)\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  foreach(jj[kk])\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    foreach (jj[kk])\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  while(jj[kk])\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    while (jj[kk])\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  do s=y;while(jj[kk]);\t"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    do\n"
+        "      s = y;\n"
+        "    while (jj[kk]);\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)  \n"
+        "  case(jj)\tS:s = y;endcase\t"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    case (jj)\n"
+        "      S: s = y;\n"
+        "    endcase\n"
+        "endmodule\n",
+    },
+
+    {
+        "module always_if ;"
+        "always@ ( posedge   clk ) if (expr) z<=y;"
+        "endmodule\n",
+        "module always_if;\n"
+        "  always @(posedge clk)\n"  // doesn't fit
+        "    if (expr)\n"
+        "      z <= y;\n"
+        "endmodule\n",
+    },
+    {
+        "module always_if ;"
+        "always@*  if (expr) z<=y;"
+        "endmodule\n",
+        "module always_if;\n"
+        "  always @* if (expr) z <= y;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else ;"
+        "always@*  if (expr) z<=y; else g<=0;"
+        "endmodule\n",
+        "module always_if_else;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"  // fits
+        "    else g <= 0;\n"       // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else_if ;"
+        "always@*  if (expr) z<=y; else if (w) g<=0;"
+        "endmodule\n",
+        "module always_if_else_if;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"    // fits
+        "    else if (w) g <= 0;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else_if_else ;"
+        "always@*  if (expr) z<=y; else if (w) g<=0;else h<=1;"
+        "endmodule\n",
+        "module always_if_else_if_else;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"    // fits
+        "    else if (w) g <= 0;\n"  // fits
+        "    else h <= 1;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(b,  c)"
+        "  for (;;)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(b, c) for (;;) s = y;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  for (i=0;i<k;++i)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    for (i = 0; i < k; ++i)\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  repeat (jj+kk)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    repeat (jj + kk)\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  foreach(jj[kk])\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    foreach (jj[kk])\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  while(jj[kk])\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    while (jj[kk])\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  do s=y;while(jj[kk]);\t"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    do\n"
+        "      s = y;\n"
+        "    while (jj[kk]);\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)  \n"
+        "  case(jj)\tS:s = y;endcase\t"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    case (jj)\n"
+        "      S: s = y;\n"
+        "    endcase\n"
+        "endmodule\n",
+    },
+
+    {
+        "module always_if ;"
+        "always@ ( posedge   clk ) if (expr) z<=y;"
+        "endmodule\n",
+        "module always_if;\n"
+        "  always @(posedge clk)\n"  // doesn't fit
+        "    if (expr)\n"
+        "      z <= y;\n"
+        "endmodule\n",
+    },
+    {
+        "module always_if ;"
+        "always@*  if (expr) z<=y;"
+        "endmodule\n",
+        "module always_if;\n"
+        "  always @* if (expr) z <= y;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else ;"
+        "always@*  if (expr) z<=y; else g<=0;"
+        "endmodule\n",
+        "module always_if_else;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"  // fits
+        "    else g <= 0;\n"       // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else_if ;"
+        "always@*  if (expr) z<=y; else if (w) g<=0;"
+        "endmodule\n",
+        "module always_if_else_if;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"    // fits
+        "    else if (w) g <= 0;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else_if_else ;"
+        "always@*  if (expr) z<=y; else if (w) g<=0;else h<=1;"
+        "endmodule\n",
+        "module always_if_else_if_else;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"    // fits
+        "    else if (w) g <= 0;\n"  // fits
+        "    else h <= 1;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(b,  c)"
+        "  for (;;)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(b, c) for (;;) s = y;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  for (i=0;i<k;++i)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    for (i = 0; i < k; ++i)\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  repeat (jj+kk)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    repeat (jj + kk)\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  foreach(jj[kk])\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    foreach (jj[kk])\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  while(jj[kk])\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    while (jj[kk])\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  do s=y;while(jj[kk]);\t"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    do\n"
+        "      s = y;\n"
+        "    while (jj[kk]);\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)  \n"
+        "  case(jj)\tS:s = y;endcase\t"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    case (jj)\n"
+        "      S: s = y;\n"
+        "    endcase\n"
+        "endmodule\n",
+    },
+
+    {
+        "module always_if ;"
+        "always@ ( posedge   clk ) if (expr) z<=y;"
+        "endmodule\n",
+        "module always_if;\n"
+        "  always @(posedge clk)\n"  // doesn't fit
+        "    if (expr)\n"
+        "      z <= y;\n"
+        "endmodule\n",
+    },
+    {
+        "module always_if ;"
+        "always@*  if (expr) z<=y;"
+        "endmodule\n",
+        "module always_if;\n"
+        "  always @* if (expr) z <= y;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else ;"
+        "always@*  if (expr) z<=y; else g<=0;"
+        "endmodule\n",
+        "module always_if_else;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"  // fits
+        "    else g <= 0;\n"       // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else_if ;"
+        "always@*  if (expr) z<=y; else if (w) g<=0;"
+        "endmodule\n",
+        "module always_if_else_if;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"    // fits
+        "    else if (w) g <= 0;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module \talways_if_else_if_else ;"
+        "always@*  if (expr) z<=y; else if (w) g<=0;else h<=1;"
+        "endmodule\n",
+        "module always_if_else_if_else;\n"
+        "  always @*\n"
+        "    if (expr) z <= y;\n"    // fits
+        "    else if (w) g <= 0;\n"  // fits
+        "    else h <= 1;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(b,  c)"
+        "  for (;;)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(b, c) for (;;) s = y;\n"  // fits
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  for (i=0;i<k;++i)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    for (i = 0; i < k; ++i)\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  repeat (jj+kk)\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    repeat (jj + kk)\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  foreach(jj[kk])\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    foreach (jj[kk])\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  while(jj[kk])\ts = y;"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    while (jj[kk])\n"
+        "      s = y;\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)"
+        "  do s=y;while(jj[kk]);\t"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    do\n"
+        "      s = y;\n"
+        "    while (jj[kk]);\n"
+        "endmodule\n",
+    },
+    {
+        "module m;\n"
+        "always @(posedge clk)  \n"
+        "  case(jj)\tS:s = y;endcase\t"
+        "endmodule",
+        "module m;\n"
+        "  always @(posedge clk)\n"
+        "    case (jj)\n"
+        "      S: s = y;\n"
+        "    endcase\n"
+        "endmodule\n",
+    },
+
+    {
+        // begin/end with labels
+        "module m ;initial  begin:yyy\tend:yyy endmodule",
+        "module m;\n"
+        "  initial begin : yyy\n"
+        "  end : yyy\n"
+        "endmodule\n",
+    },
+    {
+        // conditional generate begin/end with labels
+        "module m ;if\n( 1)  begin:yyy\tend:yyy endmodule",
+        "module m;\n"
+        "  if (1) begin : yyy\n"
+        "  end : yyy\n"
+        "endmodule\n",
+    },
+    {
+        // begin/end with labels, nested
+        "module m ;initial  begin:yyy if(1)begin:zzz "
+        "end:zzz\tend:yyy endmodule",
+        "module m;\n"
+        "  initial begin : yyy\n"
+        "    if (1) begin : zzz\n"
+        "    end : zzz\n"
+        "  end : yyy\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;initial  begin #  1 x<=y ;end endmodule",
+        "module m;\n"
+        "  initial begin\n"
+        "    #1 x <= y;\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;initial  begin x<=y ;  y<=z;end endmodule",
+        "module m;\n"
+        "  initial begin\n"
+        "    x <= y;\n"
+        "    y <= z;\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;initial  begin # 10 x<=y ;  # 20  y<=z;end endmodule",
+        "module m;\n"
+        "  initial begin\n"
+        "    #10 x <= y;\n"
+        "    #20 y <= z;\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        // qualified variables
+        "module m ;initial  begin automatic int a; "
+        " static byte s=0;end endmodule",
+        "module m;\n"
+        "  initial begin\n"
+        "    automatic int a;\n"
+        "    static byte   s = 0;\n"  // aligned
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;initial  begin automatic int a,b; "
+        " static byte s,t;end endmodule",
+        "module m;\n"
+        "  initial begin\n"
+        "    automatic int a, b;\n"
+        "    static byte s, t;\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;initial  begin   static byte a=1,b=0;end endmodule",
+        "module m;\n"
+        "  initial begin\n"
+        "    static byte a = 1, b = 0;\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;initial  begin   const int a=0;end endmodule",
+        "module m;\n"
+        "  initial begin\n"
+        "    const int a = 0;\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;initial  begin automatic   const int a=0;end endmodule",
+        "module m;\n"
+        "  initial begin\n"
+        "    automatic const int a = 0;\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;initial  begin const  var automatic  int a=0;end endmodule",
+        "module m;\n"
+        "  initial begin\n"
+        "    const var automatic int a = 0;\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;initial  begin static byte s  ={<<{a}};end endmodule",
+        "module m;\n"
+        "  initial begin\n"
+        "    static byte s = {<<{a}};\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m ;initial  begin static int s  ={>>4{a}};end endmodule",
+        "module m;\n"
+        "  initial begin\n"
+        "    static int s = {>>4{a}};\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m; final  assert   (expr ) ;endmodule",
+        "module m;\n"
+        "  final assert (expr);\n"
+        "endmodule\n",
+    },
+    {
+        "module m; final  begin\tassert   (expr ) ;end  endmodule",
+        "module m;\n"
+        "  final begin\n"
+        "    assert (expr);\n"
+        "  end\n"
+        "endmodule\n",
+    },
+    {
+        "module m; final  assume   (expr ) ;endmodule",
+        "module m;\n"
+        "  final assume (expr);\n"
+        "endmodule\n",
+    },
+    {
+        "module m; final  cover   (expr ) ;endmodule",
+        "module m;\n"
+        "  final cover (expr);\n"
+        "endmodule\n",
+    },
+    {
+        // two consecutive clocking declarations in modules
+        " module mcd ; "
+        "clocking   cb @( posedge clk);\t\tendclocking "
+        "clocking cb2   @ (posedge  clk\n); endclocking endmodule",
+        "module mcd;\n"
+        "  clocking cb @(posedge clk);\n"
+        "  endclocking\n"
+        "  clocking cb2 @(posedge clk);\n"
+        "  endclocking\n"
+        "endmodule\n",
+    },
+    {
+        // two consecutive clocking declarations in modules, with end labels
+        " module mcd ; "
+        "clocking   cb @( posedge clk);\t\tendclocking:  cb "
+        "clocking cb2   @ (posedge  clk\n); endclocking   :cb2 endmodule",
+        "module mcd;\n"
+        "  clocking cb @(posedge clk);\n"
+        "  endclocking : cb\n"
+        "  clocking cb2 @(posedge clk);\n"
+        "  endclocking : cb2\n"
+        "endmodule\n",
+    },
+    {
+        // clocking declarations with ports in modules
+        " module mcd ; "
+        "clocking cb   @ (posedge  clk\n); input a; output b; endclocking "
+        "endmodule",
+        "module mcd;\n"
+        "  clocking cb @(posedge clk);\n"
+        "    input a;\n"
+        "    output b;\n"
+        "  endclocking\n"
+        "endmodule\n",
+    },
+    {
+        // DPI import declarations in modules
+        "module mdi;"
+        "import   \"DPI-C\" function  int add(\n) ;"
+        "import \"DPI-C\"\t\tfunction int\nsleep( input int secs );"
+        "import \"DPI-C\"\t\tfunction int\nwake( input int secs, output bit "
+        "[2:0] z);"
+        "endmodule",
+        "module mdi;\n"
+        "  import \"DPI-C\" function int add();\n"
+        "  import \"DPI-C\" function int sleep(\n"
+        "    input int secs\n"
+        "  );\n"
+        "  import \"DPI-C\" function int wake(\n"
+        "    input  int       secs,\n"
+        "    output bit [2:0] z\n"
+        "  );\n"
+        "endmodule\n",
+    },
+    {
+        // DPI export declarations in modules
+        "module m;"
+        "export \"DPI-C\" function get;"
+        "export \"DPI-C\" function mhpmcounter_get;\n"
+        "export \"DPI-C\"\t\tfunction int\nwake( input int secs, output bit "
+        "[2:0] z);"
+        "endmodule",
+        "module m;\n"
+        "  export \"DPI-C\" function get;\n"
+        "  export \"DPI-C\"\n"
+        "      function mhpmcounter_get;\n"  // doesn't fit in 40-col
+        "  export \"DPI-C\" function int wake(\n"
+        "    input  int       secs,\n"
+        "    output bit [2:0] z\n"
+        "  );\n"
+        "endmodule\n",
+    },
+    {// Two consecutive EOL comments in kDPIImportItem
+     "import \"DPI-C\" context function void foo(\n"
+     "  input bit first,\n"
+     "  // c3\n"
+     "  // c3+\n"
+     "  input bit second\n"
+     ");\n",
+     "import \"DPI-C\" context\n"
+     "    function void foo(\n"
+     "  input bit first,\n"
+     "  // c3\n"
+     "  // c3+\n"
+     "  input bit second\n"
+     ");\n"},
+    {"export \"\" t;\n", "export \"\" t;\n"},
+    {"import \"DPI-C\" context function void func(input bit impl_i,"
+     "input bit op_i,"
+     "input bit [5:0] mode_i,"
+     "input bit [3:0][31:0] iv_i,"
+     "input bit [2:0] key_len_i,"
+     "input bit [7:0][31:0] key_i,"
+     "input bit [7:0] data_i[],"
+     "output bit [7:0] data_o[]);",
+     "import \"DPI-C\" context\n"
+     "    function void func(\n"
+     "  input  bit             impl_i,\n"
+     "  input  bit             op_i,\n"
+     "  input  bit [5:0]       mode_i,\n"
+     "  input  bit [3:0][31:0] iv_i,\n"
+     "  input  bit [2:0]       key_len_i,\n"
+     "  input  bit [7:0][31:0] key_i,\n"
+     "  input  bit [7:0]       data_i   [],\n"
+     "  output bit [7:0]       data_o   []\n"
+     ");\n"},
+    {// module with system task call w or w/o parentheses
+     "module m; initial begin #10 $display(\"foo\"); $display(\"bar\");"
+     "end endmodule",
+     "module m;\n"
+     "  initial begin\n"
+     "    #10 $display(\"foo\");\n"
+     "    $display(\"bar\");\n"
+     "  end\n"
+     "endmodule\n"},
+    {// module with system task call
+     "module m; initial begin #10 $display; $display;"
+     "end endmodule",
+     "module m;\n"
+     "  initial begin\n"
+     "    #10 $display;\n"
+     "    $display;\n"
+     "  end\n"
+     "endmodule\n"},
+
+};
+
+TEST(FormatterEndToEndTest, ModuleFormatterTestCases) {
+  RunFormatterTestCases40(kModuleFormatterTestCases);
+}
+
+}  // namespace
+}  // namespace formatter
+}  // namespace verilog
diff --git a/verible/verilog/formatting/formatter_test.cc b/verible/verilog/formatting/formatter_test.cc
index 9677489..894254f 100644
--- a/verible/verilog/formatting/formatter_test.cc
+++ b/verible/verilog/formatting/formatter_test.cc
@@ -1,4 +1,4 @@
-// Copyright 2017-2020 The Verible Authors.
+// Copyright 2017-2026 The Verible Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,42 +13,24 @@
 // limitations under the License.
 
 // Test cases in this file should be *insensitive* to wrapping penalties.
-// Penalty-sensitive tests belong in formatter_tuning_test.cc.
-// Methods for keeping tests penalty insensitive:
-//   * Short lines and partitions.  Lines that fit need no wrapping.
-//   * Forced line breaks using //comments (reduce decision-making)
+// Penalty-sensitive tests belong in formatter-tuning_test.cc.
+// Thematic end-to-end cases live in sibling formatter_*_test.cc files.
+// New GitHub-issue regressions belong in formatter_issue_regression_test.cc.
 
 #include "verible/verilog/formatting/formatter.h"
 
-#include <cctype>
-#include <cstddef>
 #include <memory>
 #include <sstream>
-#include <string>
 #include <string_view>
-#include <vector>
 
 #include "absl/log/die_if_null.h"
 #include "absl/status/status.h"
-#include "absl/strings/match.h"
-#include "absl/strings/str_split.h"
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "verible/common/formatting/align.h"
-#include "verible/common/formatting/basic-format-style.h"
-#include "verible/common/strings/display-utils.h"
-#include "verible/common/strings/position.h"
 #include "verible/common/text/text-structure.h"
-#include "verible/common/util/interval.h"
 #include "verible/common/util/logging.h"
 #include "verible/verilog/analysis/verilog-analyzer.h"
 #include "verible/verilog/formatting/format-style.h"
-
-#undef EXPECT_OK
-#define EXPECT_OK(value) EXPECT_TRUE((value).ok())
-
-#undef ASSERT_OK
-#define ASSERT_OK(value) ASSERT_TRUE((value).ok())
+#include "verible/verilog/formatting/formatter-test-utils.h"
 
 namespace verilog {
 namespace formatter {
@@ -63,12 +45,7 @@
 static constexpr VerilogPreprocess::Config kDefaultPreprocess;
 
 using absl::StatusCode;
-using testing::HasSubstr;
-using verible::AlignmentPolicy;
-using verible::IndentationStyle;
-using verible::LineNumberSet;
 
-// Tests that clean output passes.
 TEST(VerifyFormattingTest, NoError) {
   const std::string_view code("class c;endclass\n");
   const std::unique_ptr<VerilogAnalyzer> analyzer =
@@ -114,15 +91,6 @@
   EXPECT_EQ(status.code(), StatusCode::kDataLoss);
 }
 
-struct FormatterTestCase {
-  std::string_view input;
-  std::string_view expected;
-};
-
-static const LineNumberSet kEnableAllLines;
-
-// Test that the expected output is produced with the formatter using a custom
-// FormatStyle.
 TEST(FormatterTest, FormatCustomStyleTest) {
   static constexpr FormatterTestCase kTestCases[] = {
       {"", ""},
@@ -146,20817 +114,18 @@
   }
 }
 
-static constexpr FormatterTestCase kFormatterTestCases[] = {
+// Small smoke subset; thematic cases live in sibling formatter_*_test.cc files.
+static constexpr FormatterTestCase kSmokeFormatterTestCases[] = {
     {"", ""},
     {"\n", "\n"},
     {"\n\n", "\n\n"},
     {"\t//comment\n", "//comment\n"},
     {"\t/*comment*/\n", "/*comment*/\n"},
     {"\t/*multi-line\ncomment*/\n", "/*multi-line\ncomment*/\n"},
-    // preprocessor test cases
-    {"`include    \"path/to/file.vh\"\n", "`include \"path/to/file.vh\"\n"},
-    {"`include    `\"path/to/file.vh`\"\n", "`include `\"path/to/file.vh`\"\n"},
-    {"`define    FOO\n", "`define FOO\n"},
-    {"`define    FOO   BAR\n", "`define FOO BAR\n"},
-    {"`define    FOO\n"
-     "`define  BAR\n",
-     "`define FOO\n"
-     "`define BAR\n"},
-    {"`define FOO_``BAR 1\n", "`define FOO_``BAR 1\n"},
-    {"`define FOO_```BAR 1\n", "`define FOO_```BAR 1\n"},
-    {"`define FOO ``BAR\n", "`define FOO ``BAR\n"},
-    {"`define A``B``C 2\n", "`define A``B``C 2\n"},
-    {"`define A(x)``y\n", "`define A(x) ``y\n"},
-    {"`define    FOO_``BAR\n", "`define FOO_``BAR\n"},
-    {"`ifndef    FOO\n"
-     "`endif // FOO\n",
-     "`ifndef FOO\n"
-     "`endif  // FOO\n"},
-    {"`ifndef    FOO\n"
-     "`define   BAR\n"
-     "`endif\n",
-     "`ifndef FOO\n"
-     "`define BAR\n"
-     "`endif\n"},
-    {"`ifndef    FOO\n"
-     "`define   BAR\n\n"  // one more blank line
-     "`endif\n",
-     "`ifndef FOO\n"
-     "`define BAR\n\n"
-     "`endif\n"},
-    {"`define    FOO   \\\n"
-     "  BAR\n",
-     "`define FOO \\\n"  // TODO(b/72527558): right align '\'s to column limit
-     "  BAR\n"},
-    {"`define    FOOOOOOOOOOOOOOOO   \\\n"
-     "  BAAAAAAAAAAAAAAAAR BAAAAAAAAAAAAAZ;\n",
-     "`define FOOOOOOOOOOOOOOOO \\\n"  // macro text starts at '\'
-     "  BAAAAAAAAAAAAAAAAR BAAAAAAAAAAAAAZ;\n"},
-    {"`ifdef      FOO\n"
-     "  `fine()\n"
-     "`else\n"
-     "  `error()\n"
-     "`endif\n",
-     "`ifdef FOO\n"
-     "`fine()\n"
-     "`else\n"
-     "`error()\n"
-     "`endif\n"},
-    {"`ifdef      FOO\n"
-     "  `fine()\n"
-     "`else // trouble\n"
-     "  `error()\n"
-     "`endif\n",
-     "`ifdef FOO\n"
-     "`fine()\n"
-     "`else  // trouble\n"
-     "`error()\n"
-     "`endif\n"},
-    {"`ifdef      FOO\n"
-     "  `fine()\n"
-     "`else /* trouble */\n"
-     "  `error()\n"
-     "`endif\n",
-     "`ifdef FOO\n"
-     "`fine()\n"
-     "`else  /* trouble */\n"
-     "`error()\n"
-     "`endif\n"},
-    {"    // lonely comment\n", "// lonely comment\n"},
-    {"    // first comment\n"
-     "  // last comment\n",
-     "// first comment\n"
-     "// last comment\n"},
-    {"    // starting comment\n"
-     "  `define   FOO\n",
-     "// starting comment\n"
-     "`define FOO\n"},
-    {"  `define   FOO\n"
-     "   // trailing comment\n",
-     "`define FOO\n"
-     "// trailing comment\n"},
-    {"  `define   FOO\n"
-     "   // trailing comment 1\n"
-     "      // trailing comment 2\n",
-     "`define FOO\n"
-     "// trailing comment 1\n"
-     "// trailing comment 2\n"},
-    {
-        "  `define   FOO    \\\n"  // multiline macro definition
-        " 1\n",
-        "`define FOO \\\n"
-        " 1\n"  // TODO(b/141517267): Reflowing macro definitions
-    },
-    {"`define FOO    \\\n"  // multiline macro definition
-     "        b\n",
-     "`define FOO \\\n"  // no need to align '\'
-     "        b\n"},
-    {"`define FOO    \\\n"  // multiline macro definition
-     "        a +    \\\n"
-     "        b\n",
-     "`define FOO    \\\n"  // preserve spacing before '\'
-     "        a +    \\\n"  // to stay aligned with this one
-     "        b\n"},
-    {"    // comment with backslash\\\n", "// comment with backslash\\\n"},
-    {// macro with MacroArg tokens as arguments
-     "`FOOOOOO(\nbar1...\n,\nbar2...\n,\nbar3...\n,\nbar4\n)\n",
-     "`FOOOOOO(bar1..., bar2..., bar3...,\n"
-     "         bar4)\n"},
-    {// macro declaration exceeds line length limit
-     "`F_MACRO(looooooong_type if_it_fits_I_sits)\n",
-     "`F_MACRO(\n"
-     "    looooooong_type if_it_fits_I_sits)\n"},
-    {// macro call with not fitting arguments
-     "`MACRO_FFFFFFFFFFF("
-     "type_a_aaaa,type_b_bbbbb,"
-     "type_c_cccccc,type_d_dddddddd,"
-     "type_e_eeeeeeee,type_f_ffff)\n",
-     "`MACRO_FFFFFFFFFFF(\n"
-     "    type_a_aaaa, type_b_bbbbb,\n"
-     "    type_c_cccccc, type_d_dddddddd,\n"
-     "    type_e_eeeeeeee, type_f_ffff)\n"},
-    {// nested macro call
-     "`MACRO_FFFFFFFFFFF( "
-     "`A(type_a_aaaa), `B(type_b_bbbbb), "
-     "`C(type_c_cccccc), `D(type_d_dddddddd), "
-     "`E(type_e_eeeeeeee), `F(type_f_ffff))\n",
-     "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa),\n"
-     "                   `B(type_b_bbbbb),\n"
-     "                   `C(type_c_cccccc),\n"
-     "                   `D(type_d_dddddddd),\n"
-     "                   `E(type_e_eeeeeeee),\n"
-     "                   `F(type_f_ffff))\n"},
-    {// two-level nested macro call
-     "`MACRO_FFFFFFFFFFF( "
-     "`A(type_a_aaaa, `B(type_b_bbbbb)), "
-     "`C(type_c_cccccc, `D(type_d_dddddddd)), "
-     "`E(type_e_eeeeeeee, `F(type_f_ffff)))\n",
-     "`MACRO_FFFFFFFFFFF(\n"
-     "    `A(type_a_aaaa, `B(type_b_bbbbb)),\n"
-     "    `C(type_c_cccccc,\n"
-     "       `D(type_d_dddddddd)),\n"
-     "    `E(type_e_eeeeeeee,\n"
-     "       `F(type_f_ffff)))\n"},
-    {// three-level nested macro call
-     "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa,"
-     "`B(type_b_bbbbb,`C(type_c_cccccc))),"
-     "`D(type_d_dddddddd,`E(type_e_eeeeeeee,"
-     "`F(type_f_ffff))))\n",
-     "`MACRO_FFFFFFFFFFF(\n"
-     "    `A(type_a_aaaa,\n"
-     "       `B(type_b_bbbbb,\n"
-     "          `C(type_c_cccccc))),\n"
-     "    `D(type_d_dddddddd,\n"
-     "       `E(type_e_eeeeeeee,\n"
-     "          `F(type_f_ffff))))\n"},
-    {// macro call with MacroArg tokens as arugments and with semicolon
-     "`FOOOOOO(\nbar1...\n,\nbar2...\n,\nbar3...\n,\nbar4\n);\n",
-     "`FOOOOOO(bar1..., bar2..., bar3...,\n"
-     "         bar4);\n"},
-    {// macro declaration exceeds line length limit and contains semicolon
-     "`F_MACRO(looooooong_type if_it_fits_I_sits);\n",
-     "`F_MACRO(\n"
-     "    looooooong_type if_it_fits_I_sits);\n"},
-    {// macro call with not fitting arguments and semicolon
-     "`MACRO_FFFFFFFFFFF("
-     "type_a_aaaa,type_b_bbbbb,"
-     "type_c_cccccc,type_d_dddddddd,"
-     "type_e_eeeeeeee,type_f_ffff);\n",
-     "`MACRO_FFFFFFFFFFF(\n"
-     "    type_a_aaaa, type_b_bbbbb,\n"
-     "    type_c_cccccc, type_d_dddddddd,\n"
-     "    type_e_eeeeeeee, type_f_ffff);\n"},
-    {// nested macro call with semicolon
-     "`MACRO_FFFFFFFFFFF( "
-     "`A(type_a_aaaa), `B(type_b_bbbbb), "
-     "`C(type_c_cccccc), `D(type_d_dddddddd), "
-     "`E(type_e_eeeeeeee), `F(type_f_ffff));\n",
-     "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa),\n"
-     "                   `B(type_b_bbbbb),\n"
-     "                   `C(type_c_cccccc),\n"
-     "                   `D(type_d_dddddddd),\n"
-     "                   `E(type_e_eeeeeeee),\n"
-     "                   `F(type_f_ffff));\n"},
-    {// two-level nested macro call with semicolon
-     "`MACRO_FFFFFFFFFFF( "
-     "`A(type_a_aaaa, `B(type_b_bbbbb)), "
-     "`C(type_c_cccccc, `D(type_d_dddddddd)), "
-     "`E(type_e_eeeeeeee, `F(type_f_ffff)));\n",
-     "`MACRO_FFFFFFFFFFF(\n"
-     "    `A(type_a_aaaa, `B(type_b_bbbbb)),\n"
-     "    `C(type_c_cccccc,\n"
-     "       `D(type_d_dddddddd)),\n"
-     "    `E(type_e_eeeeeeee,\n"
-     "       `F(type_f_ffff)));\n"},
-    {// three-level nested macro call with semicolon
-     "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa,"
-     "`B(type_b_bbbbb,`C(type_c_cccccc))),"
-     "`D(type_d_dddddddd,`E(type_e_eeeeeeee,"
-     "`F(type_f_ffff))));\n",
-     "`MACRO_FFFFFFFFFFF(\n"
-     "    `A(type_a_aaaa,\n"
-     "       `B(type_b_bbbbb,\n"
-     "          `C(type_c_cccccc))),\n"
-     "    `D(type_d_dddddddd,\n"
-     "       `E(type_e_eeeeeeee,\n"
-     "          `F(type_f_ffff))));\n"},
-    {// macro call with no args
-     "`FOOOOOO()\n", "`FOOOOOO()\n"},
-    {// macro call with no args and semicolon
-     "`FOOOOOO();\n", "`FOOOOOO();\n"},
-    {// macro call with no args and semicolon separated by space
-     "`FOOOOOO() ;\n", "`FOOOOOO();\n"},
-    {// macro call with comments in argument list
-     "`FOO(aa, //aa\nbb , // bb\ncc)\n",
-     "`FOO(aa,  //aa\n"
-     "     bb,  // bb\n"
-     "     cc)\n"},
-    {// macro call with comment before first argument
-     "`FOO(//aa\naa, //bb\nbb , // cc\ncc)\n",
-     "`FOO(  //aa\n"
-     "    aa,  //bb\n"
-     "    bb,  // cc\n"
-     "    cc)\n"},
-    {// macro call with argument including trailing EOL comment
-     "`FOO(aa, bb,//cc\ndd)\n",
-     "`FOO(aa, bb,  //cc\n"
-     "     dd)\n"},
-    {// macro call with argument including EOL comment on own line
-     "`FOOOO(aa, bb,\n//cc\ndd)\n",
-     "`FOOOO(aa, bb,\n"
-     "       //cc\n"
-     "       dd)\n"},
-    {"  // leading comment\n"
-     "  `define   FOO    \\\n"  // multiline macro definition
-     "1\n"
-     "   // trailing comment\n",
-     "// leading comment\n"
-     "`define FOO \\\n"
-     "1\n"  // TODO(b/141517267): Reflowing macro definitions
-     "// trailing comment\n"},
-    {// macro call after define
-     "`define   FOO   BAR\n"
-     "  `FOO( bar )\n",
-     "`define FOO BAR\n"
-     "`FOO(bar)\n"},
-    {// multiple argument macro call
-     "  `FOO( bar , baz )\n", "`FOO(bar, baz)\n"},
-    {// long macro call breaking
-     " `ASSERT_INIT(S, (D == 4 && K inside {0, 1}) ||"
-     " (D == 3 && K== 4))\n",
-     "`ASSERT_INIT(\n"
-     "    S, (D == 4 && K inside {0, 1}) ||\n"
-     "           (D == 3 && K == 4))\n"},
-    {// long macro call breaking
-     " `AINIT(S, (D == 4 && K inside {0, 1}) ||"
-     " (D == 3 && K== 4))\n",
-     "`AINIT(S, (D == 4 && K inside {0, 1}) ||\n"
-     "              (D == 3 && K == 4))\n"},
-    {// long macro call breaking
-     " `ASSERT_INIT(S, D == 4 && K inside {0, 1})\n",
-     "`ASSERT_INIT(S,\n"
-     "             D == 4 && K inside {0, 1})\n"},
-    {// macro call in function
-     "function void foo( );   foo=`FOO( bar , baz ) ; endfunction\n",
-     "function void foo();\n"
-     "  foo = `FOO(bar, baz);\n"
-     "endfunction\n"},
-    {// nested macro call in function
-     "function void foo( );   foo=`FOO( `BAR ( baz ) ) ; endfunction\n",
-     "function void foo();\n"
-     "  foo = `FOO(`BAR(baz));\n"
-     "endfunction\n"},
-    {// macro call in class
-     "class foo;    `FOO  ( bar , baz ) ; endclass\n",
-     "class foo;\n"
-     "  `FOO(bar, baz);\n"
-     "endclass\n"},
-    {// nested macro call in class
-     "class foo;    `FOO  ( `BAR ( baz1 , baz2 ) ) ; endclass\n",
-     "class foo;\n"
-     "  `FOO(`BAR(baz1, baz2));\n"
-     "endclass\n"},
-    {// multi-line macro arg "aaaa..." should start on its own line,
-     // even if its first line would fit under the column limit
-     "`CHECK_FATAL(rd_tr,\n"
-     "             aaaa     == zzz;\n"
-     "             ggg      == vv::w;,\n"
-     "             \"Failed to ..........\")\n",
-     "`CHECK_FATAL(rd_tr,\n"
-     "             aaaa     == zzz;\n"
-     "             ggg      == vv::w;,\n"
-     "             \"Failed to ..........\")\n"},
-    {// macro call nested with function call containing an ifdef
-     "`J(D(`ifdef e))\n",
-     "`J(D(\n"
-     "   `ifdef e))\n"},
-
-    // `uvm macros indenting
-    {
-        // simple test case
-        "`uvm_object_utils_begin(aa)\n"
-        "`uvm_field_int(bb, UVM_DEFAULT)\n"
-        "`uvm_field_int(cc, UVM_DEFAULT)\n"
-        "`uvm_object_utils_end\n",
-        "`uvm_object_utils_begin(aa)\n"
-        "  `uvm_field_int(bb, UVM_DEFAULT)\n"
-        "  `uvm_field_int(cc, UVM_DEFAULT)\n"
-        "`uvm_object_utils_end\n",
-    },
-    {// multiple uvm.*begin - uvm.*end ranges
-     "`uvm_object_utils_begin(aa)\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_object_utils_end\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_object_utils_begin(bb)\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_object_utils_end\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(cc, UVM_DEFAULT)\n",
-     "`uvm_object_utils_begin(aa)\n"
-     "  `uvm_field_int(bb, UVM_DEFAULT)\n"
-     "  `uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_object_utils_end\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_object_utils_begin(bb)\n"
-     "  `uvm_field_int(bb, UVM_DEFAULT)\n"
-     "  `uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_object_utils_end\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(cc, UVM_DEFAULT)\n"},
-    {
-        // empty uvm.*begin - uvm.*end range
-        "`uvm_component_utils_begin(aa)\n"
-        "`uvm_component_utils_end\n",
-        "`uvm_component_utils_begin(aa)\n"
-        "`uvm_component_utils_end\n",
-    },
-    {
-        // uvm_field_utils
-        "`uvm_field_utils_begin(aa)\n"
-        "`uvm_field_int(bb, UVM_DEFAULT)\n"
-        "`uvm_field_int(cc, UVM_DEFAULT)\n"
-        "`uvm_field_utils_end\n",
-        "`uvm_field_utils_begin(aa)\n"
-        "  `uvm_field_int(bb, UVM_DEFAULT)\n"
-        "  `uvm_field_int(cc, UVM_DEFAULT)\n"
-        "`uvm_field_utils_end\n",
-    },
-    {
-        // uvm_component
-        "`uvm_component_utils_begin(aa)\n"
-        "`uvm_field_int(bb, UVM_DEFAULT)\n"
-        "`uvm_field_int(cc, UVM_DEFAULT)\n"
-        "`uvm_component_utils_end\n",
-        "`uvm_component_utils_begin(aa)\n"
-        "  `uvm_field_int(bb, UVM_DEFAULT)\n"
-        "  `uvm_field_int(cc, UVM_DEFAULT)\n"
-        "`uvm_component_utils_end\n",
-    },
-    {
-        // nested uvm macros
-        "`uvm_field_int(l0, UVM_DEFAULT)\n"
-        "`uvm_component_utils_begin(l0)\n"
-        "`uvm_field_int(l1, UVM_DEFAULT)\n"
-        "`uvm_component_utils_begin(l1)\n"
-        "`uvm_field_int(l2, UVM_DEFAULT)\n"
-        "`uvm_component_utils_begin(l2)\n"
-        "`uvm_field_int(l3, UVM_DEFAULT)\n"
-        "`uvm_component_utils_end\n"
-        "`uvm_field_int(l2, UVM_DEFAULT)\n"
-        "`uvm_component_utils_end\n"
-        "`uvm_field_int(l1, UVM_DEFAULT)\n"
-        "`uvm_component_utils_end\n"
-        "`uvm_field_int(l0, UVM_DEFAULT)\n",
-        "`uvm_field_int(l0, UVM_DEFAULT)\n"
-        "`uvm_component_utils_begin(l0)\n"
-        "  `uvm_field_int(l1, UVM_DEFAULT)\n"
-        "  `uvm_component_utils_begin(l1)\n"
-        "    `uvm_field_int(l2, UVM_DEFAULT)\n"
-        "    `uvm_component_utils_begin(l2)\n"
-        "      `uvm_field_int(l3, UVM_DEFAULT)\n"
-        "    `uvm_component_utils_end\n"
-        "    `uvm_field_int(l2, UVM_DEFAULT)\n"
-        "  `uvm_component_utils_end\n"
-        "  `uvm_field_int(l1, UVM_DEFAULT)\n"
-        "`uvm_component_utils_end\n"
-        "`uvm_field_int(l0, UVM_DEFAULT)\n",
-    },
-    {
-        // non-uvm macro
-        "`my_macro_begin(aa)\n"
-        "`my_field(b)\n"
-        "`my_field(c)\n"
-        "`my_macro_end\n",
-        "`my_macro_begin(aa)\n"
-        "`my_field(b)\n"
-        "`my_field(c)\n"
-        "`my_macro_end\n",
-    },
-    {
-        // unbalanced uvm macros: missing uvm.*end macro
-        "`uvm_component_utils_begin(aa)\n"
-        "`uvm_field_int(bb, UVM_DEFAULT)\n"
-        "`uvm_field_int(cc, UVM_DEFAULT)\n",
-        "`uvm_component_utils_begin(aa)\n"
-        "`uvm_field_int(bb, UVM_DEFAULT)\n"
-        "`uvm_field_int(cc, UVM_DEFAULT)\n",
-    },
-    {
-        // unbalanced uvm macros: missing uvm.*begin macro
-        "`uvm_field_int(bb, UVM_DEFAULT)\n"
-        "`uvm_field_int(cc, UVM_DEFAULT)\n"
-        "`uvm_component_utils_end\n",
-        "`uvm_field_int(bb, UVM_DEFAULT)\n"
-        "`uvm_field_int(cc, UVM_DEFAULT)\n"
-        "`uvm_component_utils_end\n",
-    },
-    {// unbalanced uvm macros: missing _begin macro between
-     // matching uvm.*begin-uvm.*end macros
-     "`uvm_component_utils_begin(aa)\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_component_utils_end\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_component_utils_end\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_component_utils_begin(aa)\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_component_utils_end\n",
-     "`uvm_component_utils_begin(aa)\n"
-     "  `uvm_field_int(bb, UVM_DEFAULT)\n"
-     "  `uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_component_utils_end\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_component_utils_end\n"
-     "`uvm_field_int(bb, UVM_DEFAULT)\n"
-     "`uvm_component_utils_begin(aa)\n"
-     "  `uvm_field_int(bb, UVM_DEFAULT)\n"
-     "  `uvm_field_int(cc, UVM_DEFAULT)\n"
-     "`uvm_component_utils_end\n"},
-
-    // top-level directive test cases
-    {"`timescale  1ns/1ps\n",  //
-     "`timescale 1ns / 1ps\n"},
-
-    // Multiple compiler directives should remain on separate lines
-    // (regression test for bug where they were merged onto one line)
-    {"`timescale 1 ps / 1 ps\n"
-     "`default_nettype none\n",
-     "`timescale 1 ps / 1 ps\n"
-     "`default_nettype none\n"},
-    {"`resetall\n"
-     "`timescale 1ns/1ps\n"
-     "`default_nettype wire\n",
-     "`resetall\n"
-     "`timescale 1ns / 1ps\n"
-     "`default_nettype wire\n"},
-    // Test with multiple different compiler directives
-    {"`resetall\n"
-     "`celldefine\n"
-     "`timescale 1ns/1ps\n"
-     "`default_nettype none\n",
-     "`resetall\n"
-     "`celldefine\n"
-     "`timescale 1ns / 1ps\n"
-     "`default_nettype none\n"},
-    // Test with compiler directives before module
-    {"`timescale 1ps/1ps\n"
-     "`default_nettype none\n"
-     "module foo;endmodule\n",
-     "`timescale 1ps / 1ps\n"
-     "`default_nettype none\n"
-     "module foo;\nendmodule\n"},
-    // Test with various compiler directives
-    {"`suppress_faults\n"
-     "`enable_portfaults\n"
-     "`delay_mode_distributed\n",
-     "`suppress_faults\n"
-     "`enable_portfaults\n"
-     "`delay_mode_distributed\n"},
-    {"`default_decay_time 10\n"
-     "`default_trireg_strength 50\n",
-     "`default_decay_time 10\n"
-     "`default_trireg_strength 50\n"},
-    // Alignment should ignore compiler directives; declarations align normally.
-    // Place directives at top-level between modules (valid SystemVerilog).
-    {"`timescale 1ns/1ps\n"
-     "module m;\n"
-     "  logic a;\n"
-     "  logic very_long_name;\n"
-     "endmodule\n"
-     "`default_nettype none\n"
-     "module n;\n"
-     "  logic b;\n"
-     "endmodule\n",
-     "`timescale 1ns / 1ps\n"
-     "module m;\n"
-     "  logic a;\n"
-     "  logic very_long_name;\n"
-     "endmodule\n"
-     "`default_nettype none\n"
-     "module n;\n"
-     "  logic b;\n"
-     "endmodule\n"},
-    {"`begin_keywords \"1800-2017\"\n"
-     "module test;endmodule\n"
-     "`end_keywords\n",
-     "`begin_keywords \"1800-2017\"\n"
-     "module test;\nendmodule\n"
-     "`end_keywords\n"},
-
-    // parameter test cases
-    {
-        "  parameter  int   foo=0 ;",
-        "parameter int foo = 0;\n",
-    },
-    {
-        "  parameter  int   foo=bar [ 0 ] ;",  // index expression
-        "parameter int foo = bar[0];\n",
-    },
-    {
-        "  parameter  int   foo=bar [ a+b ] ;",  // binary inside index expr
-        "parameter int foo = bar[a+b];\n",       // allowed to be 0 spaces
-                                                 // (preserved)
-    },
-    {
-        "  parameter  int   foo=bar [ a+ b ] ;",  // binary inside index expr
-        "parameter int foo = bar[a+b];\n",        // allowed to be 0 spaces
-                                                  // (symmetrized)
-    },
-    {
-        "  parameter  int   foo=bar [ a +b ] ;",  // compact binary inside
-        "parameter int foo = bar[a+b];\n",        // index expression
-    },
-    {
-        "  parameter  int   foo=bar [ a  +b ] ;",  // compact binary inside
-        "parameter int foo = bar[a+b];\n",         // index expression
-    },
-    {
-        // with line continuations
-        "  parameter  \\\nint   \\\nfoo=a+ \\\nb ;",
-        "parameter\\\n    int\\\n    foo = a +\\\n    b;\n",
-        // TODO(fangism): should text following a line continuation hang-indent?
-    },
-    // unary prefix expressions
-    {
-        "  parameter  int   foo=- 1 ;",
-        "parameter int foo = -1;\n",
-    },
-    {
-        "  parameter  int   foo=+ 7 ;",
-        "parameter int foo = +7;\n",
-    },
-    {
-        "  parameter  int   foo=- J ;",
-        "parameter int foo = -J;\n",
-    },
-    {
-        "  parameter  int   foo=- ( y ) ;",
-        "parameter int foo = -(y);\n",
-    },
-    {
-        "  parameter  int   foo=- ( z*y ) ;",
-        "parameter int foo = -(z * y);\n",
-    },
-    {
-        "  parameter  int   foo=-  z*- y  ;",
-        "parameter int foo = -z * -y;\n",
-    },
-    {
-        "  parameter  int   foo=( - 2 ) ;",  //
-        "parameter int foo = (-2);\n",
-    },
-    {
-        "  parameter  int   foo=$bar(-  z,- y ) ;",
-        "parameter int foo = $bar(-z, -y);\n",
-    },
-    {"  parameter int a=b&~(c<<d);", "parameter int a = b & ~(c << d);\n"},
-    {"  parameter int a=~~~~b;", "parameter int a = ~~~~b;\n"},
-    {"  parameter int a = ~ ~ ~ ~ b;", "parameter int a = ~~~~b;\n"},
-    {"  parameter int a   =   ~--b;", "parameter int a = ~--b;\n"},
-    {"  parameter int a   =   ~ --b;", "parameter int a = ~--b;\n"},
-    {"  parameter int a = ~ ++ b;", "parameter int a = ~++b;\n"},
-    {"  parameter int a=--b- --c;", "parameter int a = --b - --c;\n"},
-    // ^~ and ~^ are bitwise nor, but ^ ~ isn't
-    {"  parameter int a=b^~(c<<d);", "parameter int a = b ^~ (c << d);\n"},
-    {"  parameter int a=b~^(c<<d);", "parameter int a = b ~^ (c << d);\n"},
-    {"  parameter int a=b^ ~ (c<<d);", "parameter int a = b ^ ~(c << d);\n"},
-    {"  parameter int a=b ^ ~(c<<d);", "parameter int a = b ^ ~(c << d);\n"},
-
-    {"  parameter int a=b^~{c};", "parameter int a = b ^~ {c};\n"},
-    {"  parameter int a=b~^{c};", "parameter int a = b ~^ {c};\n"},
-    {"  parameter int a=b^ ~ {c};", "parameter int a = b ^ ~{c};\n"},
-    {"  parameter int a=b ^ ~{c};", "parameter int a = b ^ ~{c};\n"},
-
-    {"  parameter int a={a}^{b};", "parameter int a = {a} ^ {b};\n"},
-    {"  parameter int a={b}^(c);", "parameter int a = {b} ^ (c);\n"},
-    {"  parameter int a=b[0]^ {c};", "parameter int a = b[0] ^ {c};\n"},
-    {"  parameter int a={c}^a[b];", "parameter int a = {c} ^ a[b];\n"},
-    {"  parameter int a=(c)^{a[b]};", "parameter int a = (c) ^ {a[b]};\n"},
-
-    {"  parameter int a={^{a,^b},c};", "parameter int a = {^{a, ^b}, c};\n"},
-    {"  parameter int a=(a)^(^d[e]^{c});",
-     "parameter int a = (a) ^ (^d[e] ^ {c});\n"},
-    {"  parameter int a=(a)^(^d[e]^f[g]);",
-     "parameter int a = (a) ^ (^d[e] ^ f[g]);\n"},
-    {"  parameter int a=(b^(c^(d^e)));",
-     "parameter int a = (b ^ (c ^ (d ^ e)));\n"},
-    {"  parameter int a={b^{c^{d^e}}};",
-     "parameter int a = {b ^ {c ^ {d ^ e}}};\n"},
-    {"  parameter int a={b^{c[d^e]}};",
-     "parameter int a = {b ^ {c[d^e]}};\n"},  // allow 0 spaces inside "[d^e]"
-    {"  parameter int a={(b^c),(d^^e)};",
-     "parameter int a = {(b ^ c), (d ^ ^e)};\n"},
-
-    {"  parameter int a={(b[x]^{c[y]})};",
-     "parameter int a = {(b[x] ^ {c[y]})};\n"},
-    {"  parameter int a={d^^e[f] ^ (g)};",
-     "parameter int a = {d ^ ^e[f] ^ (g)};\n"},
-
-    // ~| is unary reduction NOR, |~ and | ~ aren't
-    {"  parameter int a=b| ~(c<<d);", "parameter int a = b | ~(c << d);\n"},
-    {"  parameter int a=b|~(c<<d);", "parameter int a = b | ~(c << d);\n"},
-    {"  parameter int a=b| ~| ( c<<d);", "parameter int a = b | ~|(c << d);\n"},
-    {"  parameter int a=b| ~| ~| ( c<<d);",
-     "parameter int a = b | ~|~|(c << d);\n"},
-    {"  parameter int a=b| ~~~( c<<d);",
-     "parameter int a = b | ~~~(c << d);\n"},
-    {
-        "  parameter  int   foo=- - 1 ;",  // double negative
-        "parameter int foo = - -1;\n",
-    },
-    {
-        "  parameter  int   ternary=1?2:3;",
-        "parameter int ternary = 1 ? 2 : 3;\n",
-    },
-    {
-        "  parameter  int   ternary=a?b:c;",
-        "parameter int ternary = a ? b : c;\n",
-    },
-    {
-        "  parameter  int   ternary=\"a\"?\"b\":\"c\";",
-        "parameter int ternary = \"a\" ? \"b\" : \"c\";\n",
-    },
-    {
-        "  parameter  int   t=`\"a`\"?`\"b`\":`\"c`\";",
-        "parameter int t = `\"a`\" ? `\"b`\" : `\"c`\";\n",
-    },
-    {
-        "  parameter  int   ternary=(a)?(b):(c);",
-        "parameter int ternary = (a) ? (b) : (c);\n",
-    },
-    {
-        "  parameter  int   ternary={a}?{b}:{c};",
-        "parameter int ternary = {a} ? {b} : {c};\n",
-    },
-    {
-        "  parameter  int   long_ternary=cond?long_option_t:long_option_f;",
-        "parameter int long_ternary = cond ?\n"
-        "    long_option_t : long_option_f;\n",
-    },
-    {
-        "  parameter  int   break_two=cond\n"
-        "? a_really_long_option_number_one:a_really_long_option_number_two;",
-        "parameter int break_two = cond ?\n"
-        "    a_really_long_option_number_one :\n"
-        "    a_really_long_option_number_two;\n",
-    },
-    {
-        "  assign   ternary=1?2:3;",
-        "assign ternary = 1 ? 2 : 3;\n",
-    },
-    {
-        "  assign   ternary=a?b:c;",
-        "assign ternary = a ? b : c;\n",
-    },
-    {
-        "  assign   ternary={a}?{b}:{c};",
-        "assign ternary = {a} ? {b} : {c};\n",
-    },
-    {
-        "  assign   break_two=cond\n"
-        "? a_really_long_option_number_one:a_really_long_option_number_two;",
-        "assign break_two = cond ?\n"
-        "    a_really_long_option_number_one :\n"
-        "    a_really_long_option_number_two;\n",
-    },
-    {
-        "assign prefetch_d     =\n"
-        "lookup_grant_ic0 ? (lookup_addr_aligned + ADDR) :\n"
-        "                   addr_i;",
-        "assign prefetch_d = lookup_grant_ic0 ?\n"
-        "    (lookup_addr_aligned + ADDR) :\n"
-        "    addr_i;\n",
-    },
-    {
-        "assign prefetch_d     =\n"
-        "lookup_grant_ic0 ? (lookup_addr + 1) :\n"
-        "                   addr_i;",
-        "assign prefetch_d = lookup_grant_ic0 ?\n"
-        "    (lookup_addr + 1) : addr_i;\n",
-    },
-    {
-        "module test;\n"
-        " assign next = // EOL\n"
-        "  foo ? '0 :\n"
-        "  cnt;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next =  // EOL\n"
-        "      foo ? '0 : cnt;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo // EOL\n"
-        "  ? '0 :\n"
-        "  cnt;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo  // EOL\n"
-        "      ? '0 : cnt;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo ? // EOL\n"
-        "  '0 :\n"
-        "  cnt;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo ?  // EOL\n"
-        "      '0 : cnt;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo ? '0 // EOL\n"
-        "  :\n"
-        "  cnt;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo ? '0  // EOL\n"
-        "      : cnt;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo ? '0 : // EOL\n"
-        "  cnt;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo ? '0 :  // EOL\n"
-        "      cnt;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo ? '0 : // EOL\n"
-        "  bar ? '1 : '0;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo ? '0 :  // EOL\n"
-        "      bar ? '1 : '0;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo ? '0 : // EOL\n"
-        "  bar // EOL2\n"
-        " ? '1 : '0;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo ? '0 :  // EOL\n"
-        "      bar  // EOL2\n"
-        "      ? '1 : '0;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo ? '0 : // EOL\n"
-        "  bar ? // EOL2\n"
-        "  '1 : '0;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo ? '0 :  // EOL\n"
-        "      bar ?  // EOL2\n"
-        "      '1 : '0;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo ? '0 : // EOL\n"
-        "  bar ? '1 // EOL2\n"
-        "  : '0;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo ? '0 :  // EOL\n"
-        "      bar ? '1  // EOL2\n"
-        "      : '0;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo ? '0 : // EOL\n"
-        "  bar ? '1 : // EOL2\n"
-        "  '0;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo ? '0 :  // EOL\n"
-        "      bar ? '1 :  // EOL2\n"
-        "      '0;\n"
-        "endmodule\n",
-    },
-    {
-        "assign prefetch_d     =\n"
-        "lookup_ic0 ? // EOL\n"
-        " (lookup_addr + 1) :// BOO\n"
-        "                   addr_i;",
-        "assign prefetch_d = lookup_ic0 ?  // EOL\n"
-        "    (lookup_addr + 1) :  // BOO\n"
-        "    addr_i;\n",
-    },
-    {
-        "module test;\n"
-        " assign next = (foo) ? '0          : // clear \n"
-        "           (bar) ? cnt + 1'b1  : // count \n"
-        "                   cnt;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = (foo) ? '0 :  // clear \n"
-        "      (bar) ? cnt + 1'b1 :  // count \n"
-        "      cnt;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = // FOO\n"
-        "  (foo) ? '0          : // clear \n"
-        "           (bar) ? cnt + 1'b1  : // count \n"
-        "                   cnt;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next =  // FOO\n"
-        "      (foo) ? '0 :  // clear \n"
-        "      (bar) ? cnt + 1'b1 :  // count \n"
-        "      cnt;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo ? a_really_long_identifier : // EOL\n"
-        "  cnt;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo ?\n"
-        "      a_really_long_identifier :  // EOL\n"
-        "      cnt;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo ? a_really_long_identifier : // EOL\n"
-        "  another_really_long_identifier;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo ?\n"
-        "      a_really_long_identifier :  // EOL\n"
-        "      another_really_long_identifier;\n"
-        "endmodule\n",
-    },
-    {
-        "module test;\n"
-        " assign next = foo ? a_really_long_identifier : "
-        "another_really_long_identifier;\n"
-        "endmodule\n",
-        "module test;\n"
-        "  assign next = foo ?\n"
-        "      a_really_long_identifier :\n"
-        "      another_really_long_identifier;\n"
-        "endmodule\n",
-    },
-    {
-        "assign m = check                ? {10'b0, foo} :\n"
-        "           (bar && (baz == '0)) ? hello        :\n"
-        "           world                ? temp1        : temp2;\n",
-        "assign m = check ? {10'b0, foo} :\n"
-        "    (bar && (baz == '0)) ? hello :\n"
-        "    world ? temp1 : temp2;\n",
-    },
-    {
-        "assign {a, b} = !(c == d) ? {1'b0, e} :\n"
-        "                ((e == f) && g) ?\n"
-        "                {1'b0, f} : (h) ?\n"
-        "                {1'b0, e} - 1'b1 :\n"
-        "                {1'b0, e} + 1'b1;\n",
-        "assign {a, b} = !(c == d) ? {1'b0, e} :\n"
-        "    ((e == f) && g) ? {1'b0, f} : (h) ?\n"
-        "    {1'b0, e} - 1'b1 : {1'b0, e} + 1'b1;\n",
-    },
-    {
-        "assign {aaaaaaaaaa, bbbbbbbbb} = {1'b0, cccccccccccccccccc[15:0]} +\n"
-        "                                 {1'b0, ddddddddddddddddd[15:0]};\n",
-        "assign {aaaaaaaaaa, bbbbbbbbb} =\n"
-        "    {1'b0, cccccccccccccccccc[15:0]} +\n"
-        "    {1'b0, ddddddddddddddddd[15:0]};\n",
-    },
-    {
-        "covergroup a(string b);\n"
-        "foobar: cross foo, bar {"
-        "ignore_bins baz = binsof(qux) intersect {1, 2, 3, 4, 5, 6, 7};"
-        "}\n"
-        "endgroup : a\n",
-        "covergroup a(string b);\n"
-        "  foobar: cross foo, bar{\n"
-        "    ignore_bins baz =\n"
-        "        binsof (qux) intersect {\n"
-        "      1, 2, 3, 4, 5, 6, 7\n"
-        "    };\n"
-        "  }\n"
-        "endgroup : a\n",
-    },
-    {
-        "assign {aa, bb} = {1'b0, cc} + {1'b0, dd};\n",
-        "assign {aa, bb} = {1'b0, cc} +\n"
-        "    {1'b0, dd};\n",
-    },
-
-    // streaming operators
-    {
-        "   parameter  int  b={ >>   { a } } ;",
-        "parameter int b = {>>{a}};\n",
-    },
-    {
-        "   parameter  int  b={ >>   { a , b,  c } } ;",
-        "parameter int b = {>>{a, b, c}};\n",
-    },
-    {
-        "   parameter  int  b={ >> 4  { a } } ;",
-        "parameter int b = {>>4{a}};\n",
-    },
-    {
-        "   parameter  int  b={ >> byte  { a } } ;",
-        "parameter int b = {>>byte{a}};\n",
-    },
-    {
-        "   parameter  int  b={ >> my_type_t  { a } } ;",
-        "parameter int b = {>>my_type_t{a}};\n",
-    },
-    {
-        "   parameter  int  b={ >> `GET_TYPE  { a } } ;",
-        "parameter int b = {>>`GET_TYPE{a}};\n",
-    },
-    {
-        "   parameter  int  b={ >> 4  {{ >> 2 { a }  }} } ;",
-        "parameter int b = {>>4{{>>2{a}}}};\n",
-    },
-    {
-        "   parameter  int  b={ <<   { a } } ;",
-        "parameter int b = {<<{a}};\n",
-    },
-    {
-        "   parameter  int  b={ <<   { a , b,  c } } ;",
-        "parameter int b = {<<{a, b, c}};\n",
-    },
-    {
-        "   parameter  int  b={ << 4  { a } } ;",
-        "parameter int b = {<<4{a}};\n",
-    },
-    {
-        "   parameter  int  b={ << byte  { a } } ;",
-        "parameter int b = {<<byte{a}};\n",
-    },
-    {
-        "   parameter  int  b={ << my_type_t  { a } } ;",
-        "parameter int b = {<<my_type_t{a}};\n",
-    },
-    {
-        "   parameter  int  b={ << `GET_TYPE  { a } } ;",
-        "parameter int b = {<<`GET_TYPE{a}};\n",
-    },
-    {
-        "   parameter  int  b={ << 4  {{ << 2 { a }  }} } ;",
-        "parameter int b = {<<4{{<<2{a}}}};\n",
-    },
-
-    // basic module test cases
-    {"module foo;endmodule:foo\n",
-     "module foo;\n"
-     "endmodule : foo\n"},
-    {"module\nfoo\n;\nendmodule\n:\nfoo\n",
-     "module foo;\n"
-     "endmodule : foo\n"},
-    {"module\tfoo\t;\tendmodule\t:\tfoo",
-     "module foo;\n"
-     "endmodule : foo\n"},
-    {"module foo;     // foo\n"
-     "endmodule:foo\n",
-     "module foo;  // foo\n"
-     "endmodule : foo\n"},
-    {"module foo;/* foo */endmodule:foo\n",
-     "module foo;  /* foo */\n"
-     "endmodule : foo\n"},
-    {"module pm #(\n"
-     "//comment\n"
-     ") (wire ww);\n"
-     "endmodule\n",
-     "module pm #(\n"
-     "    //comment\n"  // comment indented
-     ") (\n"
-     "    wire ww\n"
-     ");\n"
-     "endmodule\n"},
-    {"module pm ( ) ;\n"  // empty ports list
-     "endmodule\n",
-     "module pm ();\n"
-     "endmodule\n"},
-    {"module pm #(\n"
-     "//comment\n"
-     ") ( );\n"
-     "endmodule\n",
-     "module pm #(\n"
-     "    //comment\n"  // comment indented
-     ") ();\n"          // (); grouped together
-     "endmodule\n"},
-    {"`ifdef FOO\n"
-     "    `ifndef BAR\n"
-     "    `endif\n"
-     "`endif\n",
-     "`ifdef FOO\n"
-     "`ifndef BAR\n"
-     "`endif\n"
-     "`endif\n"},
-    {"module foo(\n"
-     "       `include \"ports.svh\"\n"
-     "         ) ; endmodule\n",
-     "module foo (\n"
-     "    `include \"ports.svh\"\n"
-     ");\n"
-     "endmodule\n"},
-    {"module foo(\n"
-     "       `define FOO\n"
-     "`undef\tFOO\n"
-     "         ) ; endmodule\n",
-     "module foo (\n"
-     "    `define FOO\n"
-     "    `undef FOO\n"
-     ");\n"
-     "endmodule\n"},
-    {"module foo(  input x  , output y ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  x,\n"  // aligned
-     "    output y\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(\n"
-     "// comment\n"
-     "  input x  , output y ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    // comment\n"
-     "    input  x,\n"  // aligned
-     "    output y\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input[2:0]x  , output y [3:0] ) ;endmodule:foo\n",
-     // each port item should be on its own line
-     "module foo (\n"
-     "    input  [2:0] x,\n"  // aligned
-     "    output       y[3:0]\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire x  , output reg yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire x,\n"  // aligned
-     "    output reg  yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire x  ,//c1\n"
-     "output reg yyy //c2\n"
-     " ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire x,   //c1\n"  // aligned
-     "    output reg  yyy  //c2\n"  // aligned
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire x  ,/* c1 */\n"
-     "output reg yyy /* c2 */\n"
-     " ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire x,   /* c1 */\n"  // aligned
-     "    output reg  yyy  /* c2 */\n"  // aligned
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(\n"
-     "// comment\n"
-     "input wire x  ,//c1\n"
-     "output reg yyy //c2\n"
-     " ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    // comment\n"
-     "    input  wire x,   //c1\n"  // aligned
-     "    output reg  yyy  //c2\n"  // aligned
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(\n"
-     "/* comment */\n"
-     "input wire x  ,/* c1 */\n"
-     "output reg yyy /* c2 */\n"
-     " ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    /* comment */\n"
-     "    input  wire x,   /* c1 */\n"  // aligned
-     "    output reg  yyy  /* c2 */\n"  // aligned
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire x  ,/* c1\n"
-     "c2\n"
-     "c3 */\n"
-     "output reg yyy /* c4 */\n"
-     " ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire x,   /* c1\n"
-     "c2\n"
-     "c3 */\n"  // TODO: align multiline comments
-     "    output reg  yyy  /* c4 */\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire x  ,/* c1 */\n"
-     "output reg yyy,\n"
-     "output z // c2\n"
-     " ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire x,    /* c1 */\n"  // aligned
-     "    output reg  yyy,\n"
-     "    output      z     // c2\n"  // aligned
-     ");\n"
-     "endmodule : foo\n"},
-    {"module m(input logic [4:0] foo,  // comment\n"
-     "input logic bar // comment\n"
-     " ) ;endmodule:m\n",
-     "module m (\n"
-     "    input logic [4:0] foo,  // comment\n"  // aligned
-     "    input logic       bar   // comment\n"  // aligned
-     ");\n"
-     "endmodule : m\n"},
-    {"module foo(  input wire x  , output yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire x,\n"  // aligned
-     "    output      yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input   x  , output reg yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input      x,\n"  // aligned
-     "    output reg yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input   x  , output reg[a:b]yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input            x,\n"  // aligned
-     "    output reg [a:b] yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input   [a:b]x  , output reg  yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input      [a:b] x,\n"  // aligned
-     "    output reg       yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input   x  , "
-     "  output logic  yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input        x,\n"  // aligned
-     "    output logic yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input   [a:c]x  , "
-     "  output logic[a-b: c]  yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input        [  a:c] x,\n"  // aligned
-     "    output logic [a-b:c] yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input   [a:c]x  , "
-     "  output logic[a - b: c]  yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input        [    a:c] x,\n"  // aligned
-     "    output logic [a - b:c] yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input   [a:c]x  , input zzz ,"
-     "  output logic[a - b: c]  yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input        [    a:c] x,\n"    // aligned []'s
-     "    input                  zzz,\n"  // aligned ids
-     "    output logic [a - b:c] yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input   [a:b]x  , "
-     "  output reg[e: f]  yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input      [a:b] x,\n"  // aligned
-     "    output reg [e:f] yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input   tri[aa: bb]x  , "
-     "  output reg[e: f]  yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  tri [aa:bb] x,\n"  // aligned
-     "    output reg [  e:f] yy\n"  // TODO(b/70310743): align ':'
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input   [a:b][c:d]x  , "
-     "  output reg[e: f]  yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input      [a:b][c:d] x,\n"  // aligned
-     "    output reg [e:f]      yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire x  [j:k], output reg yy ) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire x [j:k],\n"  // aligned
-     "    output reg  yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire x  , output reg yy [j:k]) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire x,\n"  // aligned
-     "    output reg  yy[j:k]\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire x  [p:q], output reg yy [j:k]) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire x [p:q],\n"  // aligned
-     "    output reg  yy[j:k]\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire x  [p:q][r:s], output reg yy [j:k]) "
-     ";endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire x [p:q][r:s],\n"  // aligned
-     "    output reg  yy[j:k]\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire x  [p:q][rr:ss], output reg yy [jj:kk][m:n]) "
-     ";endmodule:foo\n",
-     "module foo (\n"
-     // TODO(b/70310743): align :'s
-     "    input  wire x [  p:q][rr:ss],\n"
-     "    output reg  yy[jj:kk][  m:n]\n"  // aligned
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire   [p:q]x, output reg yy [j:k]) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire [p:q] x,\n"  // aligned
-     "    output reg        yy[j:k]\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire  x [p:q], output reg[j:k]yy) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire       x [p:q],\n"  // aligned
-     "    output reg  [j:k] yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input pkg::bar_t  x , output reg  yy) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  pkg::bar_t x,\n"  // aligned
-     "    output reg        yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input wire  x , output pkg::bar_t  yy) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  wire       x,\n"  // aligned
-     "    output pkg::bar_t yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input pkg::bar_t#(1)  x , output reg  yy) ;endmodule:foo\n",
-     "module foo (\n"  // with parameterized port type
-     "    input  pkg::bar_t#(1) x,\n"
-     "    output reg            yy\n"  // aligned
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input signed x , output reg  yy) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  signed x,\n"  // aligned
-     "    output reg    yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input signed x , output reg [m:n] yy) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  signed       x,\n"  // aligned
-     "    output reg    [m:n] yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input int signed x , output reg [m:n] yy) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  int signed       x,\n"  // aligned
-     "    output reg        [m:n] yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(  input signed x , output pkg::bar_t  yy) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input  signed     x,\n"  // aligned
-     "    output pkg::bar_t yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module somefunction ("
-     "logic clk, int   a, int b);endmodule",
-     "module somefunction (\n"
-     "    logic clk,\n"  // direction missing
-     "    int   a,\n"    // direction missing
-     "    int   b\n"     // direction missing
-     ");\n"
-     "endmodule\n"},
-    {"module somefunction ("
-     "logic clk, input int   a, int b);endmodule",
-     "module somefunction (\n"
-     "          logic clk,\n"  // direction missing
-     "    input int   a,\n"
-     "          int   b\n"  // direction missing
-     ");\n"
-     "endmodule\n"},
-    {"module somefunction ("
-     "input logic clk, input int   a, int b);endmodule",
-     "module somefunction (\n"
-     "    input logic clk,\n"
-     "    input int   a,\n"
-     "          int   b\n"  // direction missing
-     ");\n"
-     "endmodule\n"},
-    {"module somefunction ("
-     "input clk, input int   a, int b);endmodule",
-     "module somefunction (\n"
-     "    input     clk,\n"  // type missing
-     "    input int a,\n"
-     "          int b\n"
-     ");\n"
-     "endmodule\n"},
-    {"module somefunction ("
-     "input logic clk, input a, int b);endmodule",
-     "module somefunction (\n"
-     "    input logic clk,\n"
-     "    input       a,\n"  // type missing
-     "          int   b\n"   // direction missing
-     ");\n"
-     "endmodule\n"},
-    {"module t;\n"
-     "    input bit i_bit;\n"
-     "input   byte  i_byte ;\n"
-     "input chandle i_chandle;\n"
-     "input event i_event;\n"
-     "input int i_int;\n"
-     "input integer i_inte;\n"
-     "input longint i_longint;\n"
-     "input real i_real;\n"
-     "input realtime i_realtime;\n"
-     "input shortint i_shortint;\n"
-     "input shortreal i_shortreal;\n"
-     "input string i_string;\n"
-     "input time i_time;\n"
-     "     output bit o_bit;\n"
-     "output    byte   o_byte  ;  \n"
-     "output chandle o_chandle;\n"
-     "output event o_event;\n"
-     "output int o_int;\n"
-     "output integer o_inte;\n"
-     "output longint o_longint;\n"
-     "output real o_real;\n"
-     "output realtime o_realtime;\n"
-     "output shortint o_shortint;\n"
-     "output shortreal o_shortreal;\n"
-     "output string o_string;\n"
-     "output time o_time;\n"
-     "endmodule\n",
-     "module t;\n"
-     "  input bit i_bit;\n"
-     "  input byte i_byte;\n"
-     "  input chandle i_chandle;\n"
-     "  input event i_event;\n"
-     "  input int i_int;\n"
-     "  input integer i_inte;\n"
-     "  input longint i_longint;\n"
-     "  input real i_real;\n"
-     "  input realtime i_realtime;\n"
-     "  input shortint i_shortint;\n"
-     "  input shortreal i_shortreal;\n"
-     "  input string i_string;\n"
-     "  input time i_time;\n"
-     "  output bit o_bit;\n"
-     "  output byte o_byte;\n"
-     "  output chandle o_chandle;\n"
-     "  output event o_event;\n"
-     "  output int o_int;\n"
-     "  output integer o_inte;\n"
-     "  output longint o_longint;\n"
-     "  output real o_real;\n"
-     "  output realtime o_realtime;\n"
-     "  output shortint o_shortint;\n"
-     "  output shortreal o_shortreal;\n"
-     "  output string o_string;\n"
-     "  output time o_time;\n"
-     "endmodule\n"},
-    {"module t (\n"
-     "    input bit i_bit,\n"
-     "input     byte   i_byte  ,\n"
-     "input chandle i_chandle,\n"
-     "input event i_event,\n"
-     "input int i_int,\n"
-     "input integer i_inte,\n"
-     "input longint i_longint,\n"
-     "input real i_real,\n"
-     "input realtime i_realtime,\n"
-     "input shortint i_shortint,\n"
-     "input shortreal i_shortreal,\n"
-     "input string i_string,\n"
-     "input time i_time,\n"
-     "    output bit o_bit,\n"
-     "output     byte   o_byte  ,  \n"
-     "output chandle o_chandle,\n"
-     "output event o_event,\n"
-     "output int o_int,\n"
-     "output integer o_inte,\n"
-     "output longint o_longint,\n"
-     "output real o_real,\n"
-     "output realtime o_realtime,\n"
-     "output shortint o_shortint,\n"
-     "output shortreal o_shortreal,\n"
-     "output string o_string,\n"
-     "output time o_time);\n"
-     "endmodule\n",
-     "module t (\n"
-     "    input  bit       i_bit,\n"
-     "    input  byte      i_byte,\n"
-     "    input  chandle   i_chandle,\n"
-     "    input  event     i_event,\n"
-     "    input  int       i_int,\n"
-     "    input  integer   i_inte,\n"
-     "    input  longint   i_longint,\n"
-     "    input  real      i_real,\n"
-     "    input  realtime  i_realtime,\n"
-     "    input  shortint  i_shortint,\n"
-     "    input  shortreal i_shortreal,\n"
-     "    input  string    i_string,\n"
-     "    input  time      i_time,\n"
-     "    output bit       o_bit,\n"
-     "    output byte      o_byte,\n"
-     "    output chandle   o_chandle,\n"
-     "    output event     o_event,\n"
-     "    output int       o_int,\n"
-     "    output integer   o_inte,\n"
-     "    output longint   o_longint,\n"
-     "    output real      o_real,\n"
-     "    output realtime  o_realtime,\n"
-     "    output shortint  o_shortint,\n"
-     "    output shortreal o_shortreal,\n"
-     "    output string    o_string,\n"
-     "    output time      o_time\n"
-     ");\n"
-     "endmodule\n"},
-    {"module m;foo bar(.baz({larry, moe, curly}));endmodule",
-     "module m;\n"
-     "  foo bar (.baz({larry, moe, curly}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.baz({larry,// expand this\n"
-     "moe, curly}));endmodule",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .baz({\n"
-     "        larry,  // expand this\n"
-     "        moe,\n"
-     "        curly\n"
-     "      })\n"
-     "  );\n"
-     "endmodule\n"},
-    {"parameter priv_reg_t impl_csr[] = {\n"
-     "// Machine mode mode CSR\n"
-     "MVENDORID, //\n"
-     "MARCHID,   //\n"
-     "DSCRATCH0, //\n"
-     "DSCRATCH1  //\n"
-     "};",
-     "parameter priv_reg_t impl_csr[] = {\n"
-     "  // Machine mode mode CSR\n"
-     "  MVENDORID,  //\n"
-     "  MARCHID,  //\n"
-     "  DSCRATCH0,  //\n"
-     "  DSCRATCH1  //\n"
-     "};\n"},
-    {"parameter priv_reg_t impl_csr[] = {\n"
-     "// Expand elements\n"
-     "MVENDORID,\n"
-     "MARCHID,\n"
-     "DSCRATCH0,\n"
-     "DSCRATCH1\n"
-     "};",
-     "parameter priv_reg_t impl_csr[] = {\n"
-     "  // Expand elements\n"
-     "  MVENDORID,\n"
-     "  MARCHID,\n"
-     "  DSCRATCH0,\n"
-     "  DSCRATCH1\n"
-     "};\n"},
-    /* TODO(b/158131099): to fix these, reinterpret 'b' as a kPortDeclaration
-    {"module somefunction ("
-     "input logic clk, input a, b);endmodule",
-     "module somefunction (\n"
-     "    input logic clk,\n"
-     "    input       a,\n"  // type missing
-     "                b\n"  // type and direction missing
-     ");\n"
-     "endmodule\n"},
-    {"module somefunction ("
-     "input logic clk, int a, b);endmodule",
-     "module somefunction (\n"
-     "    input logic clk,\n"
-     "          int   a,\n"  // direction missing
-     "                b\n"  // type and direction missing
-     ");\n"
-     "endmodule\n"},
-     */
-    {"module foo(\n"
-     "//c1\n"
-     "input wire x , \n"
-     "//c2\n"
-     "output reg  yy\n"
-     "//c3\n"
-     ") ;endmodule:foo\n",
-     "module foo (\n"
-     "    //c1\n"
-     "    input  wire x,\n"  // aligned, ignoring comments
-     "    //c2\n"
-     "    output reg  yy\n"
-     "    //c3\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(\n"
-     "//c1\n"
-     "input wire x , \n"
-     "//c2a\n"  // longer comment
-     "//c2b\n"
-     "output reg  yy\n"
-     "//c3\n"
-     ") ;endmodule:foo\n",
-     "module foo (\n"
-     "    //c1\n"
-     "    input  wire x,\n"  // aligned, ignoring comments
-     "    //c2a\n"           // note: separated by 2 lines of comments
-     "    //c2b\n"
-     "    output reg  yy\n"
-     "    //c3\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(\n"
-     "`ifdef   FOO\n"
-     "input wire x , \n"
-     " `else\n"
-     "output reg  yy\n"
-     " `endif\n"
-     ") ;endmodule:foo\n",
-     "module foo (\n"
-     "`ifdef FOO\n"
-     "    input  wire x,\n"  // aligned, ignoring preprocessor conditionals
-     "`else\n"
-     "    output reg  yy\n"
-     "`endif\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(\n"
-     "input w , \n"
-     "`define   FOO BAR\n"
-     "input wire x , \n"
-     " `include  \"stuff.svh\"\n"
-     "output reg  yy\n"
-     " `undef    FOO\n"
-     "output zz\n"
-     ") ;endmodule:foo\n",
-     "module foo (\n"
-     "    input       w,\n"  // aligned, ignoring preprocessor directives
-     "    `define FOO BAR\n"
-     "    input  wire x,\n"
-     "    `include \"stuff.svh\"\n"
-     "    output reg  yy\n"
-     "    `undef FOO\n"
-     "    output      zz\n"  // aligned, ignoring preprocessor directives
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(\n"
-     "input wire x , \n  \n"  // blank line, separating alignment groups
-     "output reg  yy\n"
-     ") ;endmodule:foo\n",
-     "module foo (\n"
-     "    input wire x,\n"  // not aligned, due to blank line separating groups
-     "\n"
-     "    output reg yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(\n"
-     "input wire x1 [r:s],\n"
-     "input [p:q] x2 , \n  \n"  // blank line, separating alignment groups
-     "output reg  [jj:kk]yy1,\n"
-     "output pkg::barr_t [mm:nn] yy2\n"
-     ") ;endmodule:foo\n",
-     "module foo (\n"
-     "    input wire       x1[r:s],\n"  // aligned in this group, but not across
-                                        // groups
-     "    input      [p:q] x2,\n"
-     "\n"
-     "    output reg         [jj:kk] yy1,\n"
-     "    output pkg::barr_t [mm:nn] yy2\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo(\n"  // same as previous, with comments
-     " //c1\n"
-     "input wire x1 [r:s],\n"
-     "input [p:q] x2 , \n"
-     " //c2\n\n"  // blank line, separating alignment groups
-     " //c3\n"
-     "output reg  [jj:kk]yy1,\n"
-     " //c4\n"
-     "output pkg::barr_t [mm:nn] yy2\n"
-     ") ;endmodule:foo\n",
-     "module foo (\n"
-     "    //c1\n"
-     "    input wire       x1[r:s],\n"  // aligned in this group, but not across
-                                        // groups
-     "    input      [p:q] x2,\n"
-     "    //c2\n"
-     "\n"
-     "    //c3\n"
-     "    output reg         [jj:kk] yy1,\n"
-     "    //c4\n"
-     "    output pkg::barr_t [mm:nn] yy2\n"
-     ");\n"
-     "endmodule : foo\n"},
-
-    {// align null-statement (issue #824)
-     "class sample;"
-     "bit a;;"
-     "bit b;"
-     "endclass",
-     "class sample;\n"
-     "  bit a;\n"
-     "  ;\n"
-     "  bit b;\n"
-     "endclass\n"},
-    {"class sample;"
-     "bit a;;"
-     "endclass",
-     "class sample;\n"
-     "  bit a;\n"
-     "  ;\n"
-     "endclass\n"},
-    {"class sample;"
-     "bit a;"
-     "bit b;;"
-     "endclass",
-     "class sample;\n"
-     "  bit a;\n"
-     "  bit b;\n"
-     "  ;\n"
-     "endclass\n"},
-
-    {// aligning here just barely fits in the 40col limit
-     "module foo(  input int signed x [a:b],"
-     "output reg [mm:nn] yy) ;endmodule:foo\n",
-     "module foo (\n"
-     // ---------------40col----------------->
-     "    input  int signed         x [a:b],\n"  // aligned, still fits
-     "    output reg        [mm:nn] yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {// when aligning would result in exceeding column limit, don't align for
-     // now
-     "module foo(  input int signed x [aa:bb],"
-     "output reg [mm:nn] yy) ;endmodule:foo\n",
-     "module foo (\n"
-     // ---------------40col----------------->
-     //   input  int signed         x [aa:bb],\n"
-     //   output reg        [mm:nn] yy\n"
-     "    input  int signed         x [aa:bb],\n"  // aligned, still fits
-     "    output reg        [mm:nn] yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {// when aligning would result in exceeding column limit, don't align for
-     // now
-     "module foo(  input int signed x [aa:bb],"
-     "output reg [mm:nn] yyy) ;endmodule:foo\n",
-     "module foo (\n"
-     // ---------------40col----------------->
-     //   input  int signed         x  [aa:bb],\n"  // over limit, by comma
-     //   output reg        [mm:nn] yyy\n"
-     "    input int signed x[aa:bb],\n"  // aligned would be 41 columns
-     "    output reg [mm:nn] yyy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {// when aligning would result in exceeding column limit, don't align for
-     // now
-     "module foo(  input int signed x [a:b],//c\n"
-     "output reg [m:n] yy) ;endmodule:foo\n",
-     "module foo (\n"
-     // ---------------40col---------------->
-     //   input  int signed       x [a:b],  //c\n"  // over limit, by comment
-     //   output reg        [m:n] yy\n"
-     "    input int signed x[a:b],  //c\n"  // aligned would be 42 columns
-     "    output reg [m:n] yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {// aligning interfaces in port headers like types
-     // TODO(b/161181877): flush interface port type left (multi-column)
-     "module foo(  input clk , inter.face yy) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input            clk,\n"  // aligned
-     "          inter.face yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {// aligning interfaces in port headers like types
-     // TODO(b/161181877): flush interface port type left (multi-column)
-     "module foo(  input wire   clk , inter.face yy) ;endmodule:foo\n",
-     "module foo (\n"
-     "    input wire       clk,\n"  // aligned
-     "          inter.face yy\n"
-     ");\n"
-     "endmodule : foo\n"},
-
-    // module local variable/net declaration alignment test cases
-    {"module m;\n"
-     "logic a;\n"
-     "bit b;\n"
-     "endmodule\n",
-     "module m;\n"
-     "  logic a;\n"
-     "  bit   b;\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "logic a;\n"
-     "bit b;\n"
-     "initial e=f;\n"  // separates alignment groups
-     "wire c;\n"
-     "bit d;\n"
-     "endmodule\n",
-     "module m;\n"
-     "  logic a;\n"
-     "  bit   b;\n"
-     "  initial e = f;\n"  // separates alignment groups
-     "  wire c;\n"
-     "  bit  d;\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "// hello a\n"
-     "logic a;\n"
-     "// hello b\n"
-     "bit b;\n"
-     "endmodule\n",
-     "module m;\n"
-     "  // hello a\n"
-     "  logic a;\n"
-     "  // hello b\n"
-     "  bit   b;\n"  // aligned across comments
-     "endmodule\n"},
-    {"module m;\n"
-     "// hello a\n"
-     "logic a;\n"
-     "\n"  // extra blank line
-     "// hello b\n"
-     "bit b;\n"
-     "endmodule\n",
-     "module m;\n"
-     "  // hello a\n"
-     "  logic a;\n"
-     "\n"              // extra blank line
-     "  // hello b\n"  // aligned across blank lines
-     "  bit   b;\n"    // aligned across comments
-     "endmodule\n"},
-    {"module m;\n"
-     "logic [x:y]a;\n"  // packed dimensions
-     "bit b;\n"
-     "endmodule\n",
-     "module m;\n"
-     "  logic [x:y] a;\n"
-     "  bit         b;\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "logic a;\n"
-     "bit [pp:qq]b;\n"  // packed dimensions
-     "endmodule\n",
-     "module m;\n"
-     "  logic         a;\n"
-     "  bit   [pp:qq] b;\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "logic [x:y]a;\n"  // packed dimensions
-     "bit [pp:qq]b;\n"  // packed dimensions
-     "endmodule\n",
-     "module m;\n"
-     "  logic [  x:y] a;\n"
-     "  bit   [pp:qq] b;\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "logic [x:y]a;\n"         // packed dimensions
-     "wire [pp:qq] [e:f]b;\n"  // packed dimensions, 2D
-     "endmodule\n",
-     "module m;\n"
-     "  logic [  x:y]      a;\n"
-     "  wire  [pp:qq][e:f] b;\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "logic a [x:y];\n"  // unpacked dimensions
-     "bit bbb;\n"
-     "endmodule\n",
-     "module m;\n"
-     "  logic a   [x:y];\n"
-     "  bit   bbb;\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "logic aaa ;\n"
-     "wire w [yy:zz];\n"  // unpacked dimensions
-     "endmodule\n",
-     "module m;\n"
-     "  logic aaa;\n"
-     "  wire  w   [yy:zz];\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "logic aaa [s:t] ;\n"  // unpacked dimensions
-     "wire w [yy:zz];\n"    // unpacked dimensions
-     "endmodule\n",
-     "module m;\n"
-     "  logic aaa[  s:t];\n"
-     "  wire  w  [yy:zz];\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "logic aaa [s:t] ;\n"     // unpacked dimensions
-     "wire w [yy:zz][u:v];\n"  // unpacked dimensions, 2D
-     "endmodule\n",
-     "module m;\n"
-     "  logic aaa[  s:t];\n"
-     "  wire  w  [yy:zz] [u:v];\n"
-     // TODO(b/165323560): unwanted space between unpacked dimensions of 'w'
-     "endmodule\n"},
-    {"module m;\n"
-     "qqq::rrr s;\n"     // user-defined type
-     "wire [pp:qq]w;\n"  // packed dimensions
-     "endmodule\n",
-     "module m;\n"
-     "  qqq::rrr         s;\n"
-     "  wire     [pp:qq] w;\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "qqq#(rr) s;\n"     // parameterized type
-     "wire [pp:qq]w;\n"  // packed dimensions
-     "endmodule\n",
-     "module m;\n"
-     "  qqq #(rr)         s;\n"
-     "  wire      [pp:qq] w;\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "logic a;\n"
-     "bit b;\n"
-     "my_module  my_inst( );\n"  // module instance separates alignment groups
-     "wire c;\n"
-     "bit d;\n"
-     "endmodule\n",
-     "module m;\n"
-     "  logic a;\n"  // these two are aligned
-     "  bit   b;\n"
-     "  my_module my_inst ();\n"  // module instance separates alignment groups
-     "  wire c;\n"                // these two are aligned
-     "  bit  d;\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "logic aaa = expr1;\n"
-     "bit b = expr2;\n"
-     "endmodule\n",
-     "module m;\n"
-     "  logic aaa = expr1;\n"
-     "  bit   b = expr2;\n"  // no alignment at '=' yet
-     "endmodule\n"},
-    {"(* foo='{\"bar_.*\"} *)\n"  // funny attribute
-     "module mattr;\n"
-     "(* attr1=\"value1\" *)\n"  // attribute ignored
-     "ex_input_pins_t ex_input_pins;\n"
-     "(* attr2=\"value2\" *)\n"  // attribute ignored
-     "ex_output_pins_t ex_output_pins;\n"
-     "(* attr3=\"value3\" *)\n"  // attribute ignored
-     "ex wrap_ex ( );\n"
-     "endmodule\n",
-     "(* foo='{\"bar_.*\"} *)\n"
-     "module mattr;\n"
-     "  (* attr1=\"value1\" *)\n"           // indented
-     "  ex_input_pins_t  ex_input_pins;\n"  // aligned
-     "  (* attr2=\"value2\" *)\n"           // indented
-     "  ex_output_pins_t ex_output_pins;\n"
-     "  (* attr3=\"value3\" *)\n"  // indented
-     "  ex wrap_ex ();\n"
-     "endmodule\n"},
-    {"module mattr;\n"
-     "ex_input_pins_t ex_input_pins;\n"
-     "ex_output_pins_t ex_output_pins;\n"
-     "(* package_definition=\"ex_pkg\" *)\n"  // attribute ignored
-     "ex wrap_ex (\n"
-     ".clk(ex_input_pins.clk),\n"
-     ".rst(ex_input_pins.rst),\n"
-     ".in(ex_input_pins.in)\n"
-     ");\n"
-     "endmodule\n",
-     "module mattr;\n"
-     "  ex_input_pins_t  ex_input_pins;\n"  // aligned
-     "  ex_output_pins_t ex_output_pins;\n"
-     "  (* package_definition=\"ex_pkg\" *)\n"  // indented
-     "  ex wrap_ex (\n"
-     "      .clk(ex_input_pins.clk),\n"
-     "      .rst(ex_input_pins.rst),\n"
-     "      .in (ex_input_pins.in)\n"  // aligned
-     "  );\n"
-     "endmodule\n"},
-    {"module test;\n"
-     "bind entropy_src tlul_assert #(.EndpointType(\"Device\"))\n"
-     "tlul_assert_device (.clk_i, .rst_ni, .h2d(tl_i), .d2h(tl_o));\n"
-     "endmodule\n",
-     "module test;\n"
-     "  bind entropy_src tlul_assert #(\n"
-     "      .EndpointType(\"Device\")\n"
-     "  ) tlul_assert_device (\n"
-     "      .clk_i,\n"
-     "      .rst_ni,\n"
-     "      .h2d(tl_i),\n"
-     "      .d2h(tl_o)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module test;\n"
-     "bind entropy_src tlul_assert #(.EndpointType(\"Device\"))\n"
-     "tlul_assert_device (.clk_i, .rst_ni,\n\n .h2d(tl_i),\n\n .d2h(tl_o));\n"
-     "endmodule\n",
-     "module test;\n"
-     "  bind entropy_src tlul_assert #(\n"
-     "      .EndpointType(\"Device\")\n"
-     "  ) tlul_assert_device (\n"
-     "      .clk_i,\n"
-     "      .rst_ni,\n"
-     "\n"
-     "      .h2d(tl_i),\n"
-     "\n"
-     "      .d2h(tl_o)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"bind expand_me long_name #(.W(W_CONST), .D(D_CONST)) instaaance_name ("
-     ".in(iiiiiiiin),\n\n .out(ooooooout),\n .clk(ccccccclk),\n\n"
-     ".in1234 (in),\n //c1\n .out1234(out),\n .clk1234(clk),);",
-     "bind expand_me long_name #(\n"
-     "    .W(W_CONST),\n"
-     "    .D(D_CONST)\n"
-     ") instaaance_name (\n"
-     "    .in(iiiiiiiin),\n"
-     "\n"
-     "    .out(ooooooout),\n"
-     "    .clk(ccccccclk),\n"
-     "\n"
-     "    .in1234 (in),\n"
-     "    //c1\n"
-     "    .out1234(out),\n"
-     "    .clk1234(clk),\n"
-     ");\n"},
-    {"initial // clock generation\n begin\n clk = 0;\n forever begin\n"
-     "#4ns clk = !clk;\n end\n end\n",
-     "initial  // clock generation\n"
-     "  begin\n"
-     "    clk = 0;\n"
-     "    forever begin\n"
-     "      #4ns clk = !clk;\n"
-     "    end\n"
-     "  end\n"},
-    {"module foo #(int x,int y) ;endmodule:foo\n",  // parameters
-     "module foo #(\n"
-     "    int x,\n"
-     "    int y\n"
-     ");\n"  // each parameter on its own line
-     "endmodule : foo\n"},
-    {"module foo #(int x)(input y) ;endmodule:foo\n",
-     // parameter and port
-     "module foo #(\n"
-     "    int x\n"
-     ") (\n"
-     "    input y\n"
-     ");\n"  // each paramater and port item should be on its own line
-     "endmodule : foo\n"},
-    {"module foo #(parameter int x,parameter int y) ;endmodule:foo\n",
-     // parameters don't fit (also should be on its own line)
-     "module foo #(\n"
-     "    parameter int x,\n"
-     "    parameter int y\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo #(parameter int xxxx,parameter int yyyy) ;endmodule:foo\n",
-     // parameters don't fit
-     "module foo #(\n"
-     "    parameter int xxxx,\n"
-     "    parameter int yyyy\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo #(parameter int x = $clog2  (N) ,parameter int y ) "
-     ";endmodule:foo\n",
-     // parameters don't fit
-     "module foo #(\n"
-     "    parameter int x = $clog2(N),\n"  // no space after $clog2
-     "    parameter int y\n"
-     ");\n"
-     "endmodule : foo\n"},
-    {"module foo #(//comment\n"
-     "parameter bar =1,\n"
-     "localparam baz =2"
-     ") ();"
-     "endmodule",
-     "module foo #(  //comment\n"
-     "    parameter  bar = 1,\n"
-     "    localparam baz = 2\n"
-     ") ();\n"
-     "endmodule\n"},
-    {"module foo #("
-     "parameter  bar =1,//comment\n"
-     "localparam baz =2"
-     ") ();"
-     "endmodule",
-     "module foo #(\n"
-     "    parameter  bar = 1,  //comment\n"
-     "    localparam baz = 2\n"
-     ") ();\n"
-     "endmodule\n"},
-    {"module foo #("
-     "parameter  bar =1,"
-     "localparam baz =2//comment\n"
-     ") ();"
-     "endmodule",
-     "module foo #(\n"
-     "    parameter  bar = 1,\n"
-     "    localparam baz = 2   //comment\n"
-     ") ();\n"
-     "endmodule\n"},
-    {"module foo #("
-     "parameter  bar =1//comment\n"
-     ",localparam baz =2\n"
-     ") ();"
-     "endmodule",
-     "module foo #(\n"
-     "      parameter  bar = 1  //comment\n"
-     "    , localparam baz = 2\n"
-     ") ();\n"
-     "endmodule\n"},
-    {"module foo;"
-     // fit in one line
-     "parameter int i = '{\n"
-     "1,\n"
-     "2,\n"
-     "3\n"
-     "};\n"
-     "endmodule",
-     "module foo;\n"
-     "  parameter int i = '{1, 2, 3};\n"
-     "endmodule\n"},
-    {"module foo;"
-     // too long for one line, expand
-     "localparam logic [63:0] RC[24] = '{\n"
-     "64'h 1,\n"
-     "64'h 2,\n"
-     "64'h 3\n"
-     "};\n"
-     "endmodule",
-     "module foo;\n"
-     "  localparam logic [63:0] RC[24] = '{\n"
-     "      64'h1,\n"
-     "      64'h2,\n"
-     "      64'h3\n"
-     "  };\n"
-     "endmodule\n"},
-    {"module foo;"
-     "parameter int i = '{\n"
-     // force expansion
-     "1, //\n"
-     "2,\n"
-     "3\n"
-     "};\n"
-     "endmodule",
-     "module foo;\n"
-     "  parameter int i = '{\n"
-     "      1,  //\n"
-     "      2,\n"
-     "      3\n"
-     "  };\n"
-     "endmodule\n"},
-    {"module foo;"
-     "localparam logic [63:0] RC[24] = '{\n"
-     "64'h 0000_0000_0000_0001, // 0\n"
-     "64'h 0000_0000_0000_8082, // 1\n"
-     "64'h 8000_0000_8000_8008 // 23\n"
-     "};\n"
-     "endmodule",
-     "module foo;\n"
-     "  localparam logic [63:0] RC[24] = '{\n"
-     "      64'h0000_0000_0000_0001,  // 0\n"
-     "      64'h0000_0000_0000_8082,  // 1\n"
-     "      64'h8000_0000_8000_8008  // 23\n"
-     "  };\n"
-     "endmodule\n"},
-    {"module foo;"
-     // nest two patterns
-     "parameter logic [11:0] i = '{\n"
-     "'{1,2,3},\n"
-     "'{1,2,3}\n"
-     "};\n"
-     "endmodule",
-     "module foo;\n"
-     "  parameter logic [11:0] i = '{\n"
-     "      '{1, 2, 3},\n"
-     "      '{1, 2, 3}\n"
-     "  };\n"
-     "endmodule\n"},
-    {"module foo;"
-     // nest two patterns, expand interior
-     "parameter logic [11:0] i = '{\n"
-     "'{1, //\n"
-     " 2,3},\n"
-     "'{1,2,3}\n"
-     "};\n"
-     "endmodule",
-     "module foo;\n"
-     "  parameter logic [11:0] i = '{\n"
-     "      '{\n"
-     "          1,  //\n"
-     "          2,\n"
-     "          3\n"
-     "      },\n"
-     "      '{1, 2, 3}\n"
-     "  };\n"
-     "endmodule\n"},
-    {"module foo;"
-     // nest two patterns, expand both
-     "parameter nest [2] i = '{\n"
-     "'{first : 32'h0000_0001,\n"
-     "  second : 32'h0000_0011,\n"
-     "  third: 32'h0000_0111},\n"
-     "'{first : 32'h1000_0001,\n"
-     "  second : 32'h1000_0011,\n"
-     "  third: 32'h1000_0111}\n"
-     "};\n"
-     "endmodule",
-     "module foo;\n"
-     "  parameter nest [2] i = '{\n"
-     "      '{\n"
-     "          first : 32'h0000_0001,\n"
-     "          second : 32'h0000_0011,\n"
-     "          third: 32'h0000_0111\n"
-     "      },\n"
-     "      '{\n"
-     "          first : 32'h1000_0001,\n"
-     "          second : 32'h1000_0011,\n"
-     "          third: 32'h1000_0111\n"
-     "      }\n"
-     "  };\n"
-     "endmodule\n"},
-    {"module foo;"
-     // nest three patterns
-     "parameter logic [11:0] i = '{\n"
-     "'{'{1,2,3},4}\n"
-     "};\n"
-     "endmodule",
-     "module foo;\n"
-     "  parameter logic [11:0] i = '{\n"
-     "      '{'{1, 2, 3}, 4}\n"
-     "  };\n"
-     "endmodule\n"},
-    {"module foo;"
-     // nest three patterns, expand interior
-     "parameter logic [11:0] i = '{\n"
-     "'{\n"
-     "'{first : 32'h0000_0001,\n"
-     "  second : 32'h0000_0011,\n"
-     "  third: 32'h0000_0111},\n"
-     "  4},\n"
-     "  5,\n"
-     "  '{1,2,3}\n"
-     "};\n"
-     "endmodule",
-     "module foo;\n"
-     "  parameter logic [11:0] i = '{\n"
-     "      '{\n"
-     "          '{\n"
-     "              first : 32'h0000_0001,\n"
-     "              second : 32'h0000_0011,\n"
-     "              third: 32'h0000_0111\n"
-     "          },\n"
-     "          4\n"
-     "      },\n"
-     "      5,\n"
-     "      '{1, 2, 3}\n"
-     "  };\n"
-     "endmodule\n"},
-    {"module    top;"
-     "foo#(  \"test\"  ) foo(  );"
-     "bar#(  \"test\"  ,5) bar(  );"
-     "endmodule\n",
-     "module top;\n"
-     "  foo #(\"test\") foo ();\n"  // module instantiation, string arg
-     "  bar #(\"test\", 5) bar ();\n"
-     "endmodule\n"},
-    {"module    top;"
-     "foo#(  `\"test`\"  ) foo(  );"
-     "bar#(  `\"test`\"  ,5) bar(  );"
-     "endmodule\n",
-     "module top;\n"
-     "  foo #(`\"test`\") foo ();\n"  // module instantiation, eval string arg
-     "  bar #(`\"test`\", 5) bar ();\n"
-     "endmodule\n"},
-    {"`ifdef FOO\n"
-     "  module bar;endmodule\n"
-     "`endif\n",
-     "`ifdef FOO\n"
-     "module bar;\n"
-     "endmodule\n"
-     "`endif\n"},
-    {"`ifdef FOO\n"
-     "  module bar;endmodule\n"
-     "`else module baz;endmodule\n"
-     "`endif\n",
-     "`ifdef FOO\n"
-     "module bar;\n"
-     "endmodule\n"
-     "`else\n"
-     "module baz;\n"
-     "endmodule\n"
-     "`endif\n"},
-    {"`ifdef FOO\n"
-     "  module bar;endmodule\n"
-     "`else /* glue me */ module baz;endmodule\n"
-     "`endif\n",
-     "`ifdef FOO\n"
-     "module bar;\n"
-     "endmodule\n"
-     "`else  /* glue me */\n"
-     "module baz;\n"
-     "endmodule\n"
-     "`endif\n"},
-    {"`ifdef FOO\n"
-     "  module bar;endmodule\n"
-     "`else// different unit\n"
-     "  module baz;endmodule\n"
-     "`endif\n",
-     "`ifdef FOO\n"
-     "module bar;\n"
-     "endmodule\n"
-     "`else  // different unit\n"
-     "module baz;\n"
-     "endmodule\n"
-     "`endif\n"},
-
-    // unary: + - !  ~ & | ^  ~& ~| ~^ ^~
-    {"module m;foo bar(.x(-{a,b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x(-{a, b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(!{a,b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x(!{a, b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(~{a,b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x(~{a, b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(&{a,b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x(&{a, b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(|{a,b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x(|{a, b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(^{a,b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x(^{a, b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(~&{a,b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x(~&{a, b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(~|{a,b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x(~|{a, b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(~^{a,b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x(~^{a, b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(^~{a,b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x(^~{a, b}));\n"
-     "endmodule\n"},
-
-    // binary: + - * / % & | ^ ^~ ~^ && ||
-    {"module m;foo bar(.x(a+b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a + b));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a-b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a - b));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a*b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a * b));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a/b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a / b));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a%b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a % b));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a&b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a & b));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a|b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a | b));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a^b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a ^ b));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a^~b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a ^~ b));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a~^b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a ~^ b));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a&&b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a && b));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a||b));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a || b));\n"
-     "endmodule\n"},
-
-    // {a} op {b}
-    {"module m;foo bar(.x({a}+{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} + {b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x({a}-{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} - {b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x({a}*{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} * {b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x({a}/{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} / {b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x({a}%{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} % {b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x({a}&{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} & {b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x({a}|{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} | {b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x({a}^{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} ^ {b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x({a}^~{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} ^~ {b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x({a}~^{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} ~^ {b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x({a}&&{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} && {b}));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x({a}||{b}));endmodule",
-     "module m;\n"
-     "  foo bar (.x({a} || {b}));\n"
-     "endmodule\n"},
-
-    // (a) op (b)
-    {"module m;foo bar(.x((a)+(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) + (b)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a)-(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) - (b)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a)*(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) * (b)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a)/(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) / (b)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a)%(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) % (b)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a)&(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) & (b)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a)|(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) | (b)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a)^(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) ^ (b)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a)^~(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) ^~ (b)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a)~^(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) ~^ (b)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a)&&(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) && (b)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a)||(b)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a) || (b)));\n"
-     "endmodule\n"},
-
-    // a[b] op c
-    {"module m;foo bar(.x(a[b]+c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] + c));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b]-c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] - c));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b]*c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] * c));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b]/c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] / c));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b]%c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] % c));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b]&c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] & c));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b]|c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] | c));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b]^c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] ^ c));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b]^~c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] ^~ c));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b]~^c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] ~^ c));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b]&&c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] && c));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b]||c));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] || c));\n"
-     "endmodule\n"},
-
-    // misc
-    {"module m;foo bar(.x(a[1:0]^b[2:1]));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[1:0] ^ b[2:1]));\n"
-     "endmodule\n"},
-
-    {"module m;foo bar(.x(a[b] | b[c]));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] | b[c]));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x(a[b] & b[c]));endmodule",
-     "module m;\n"
-     "  foo bar (.x(a[b] & b[c]));\n"
-     "endmodule\n"},
-
-    {"module m;foo bar(.x((a^c)^(b^ ~c)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a ^ c) ^ (b ^ ~c)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a^c)^(b^~c)));endmodule",
-     "module m;\n"
-     "  foo bar (.x((a ^ c) ^ (b ^~ c)));\n"
-     "endmodule\n"},
-    {"module m;foo bar(.x((a^{c,d})^(b^^{c,d})));endmodule",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .x((a ^ {c, d}) ^ (b ^ ^{c, d}))\n"
-     "  );\n"
-     "endmodule\n"},
-
-    {// module items mixed with preprocessor conditionals and comments
-     "    module foo;\n"
-     "// comment1\n"
-     "  `ifdef SIM\n"
-     "// comment2\n"
-     " `elsif SYN\n"
-     " // comment3\n"
-     "       `else\n"
-     "// comment4\n"
-     " `endif\n"
-     "// comment5\n"
-     "  endmodule",
-     "module foo;\n"
-     "  // comment1\n"
-     "`ifdef SIM\n"
-     "  // comment2\n"
-     "`elsif SYN\n"
-     "  // comment3\n"
-     "`else\n"
-     "  // comment4\n"
-     "`endif\n"
-     "  // comment5\n"
-     "endmodule\n"},
-    {"  module bar;wire foo;reg bear;endmodule\n",
-     "module bar;\n"
-     "  wire foo;\n"
-     "  reg  bear;\n"  // aligned
-     "endmodule\n"},
-    {" module bar;initial\nbegin a<=b . c ; end endmodule\n",
-     "module bar;\n"
-     "  initial begin\n"
-     "    a <= b.c;\n"
-     "  end\n"
-     "endmodule\n"},
-    {"module foo ();\nif (1) begin\n$finish(\n"
-     "      1    ); $finish    ();\n  end\nendmodule",
-     "module foo ();\n"
-     "  if (1) begin\n"
-     "    $finish(1);\n"
-     "    $finish();\n"
-     "  end\n"
-     "endmodule\n"},
-    {"  module bar;for(genvar i = 0 ; i<N ; ++ i  ) begin end endmodule\n",
-     "module bar;\n"
-     "  for (genvar i = 0; i < N; ++i) begin\n"
-     "  end\n"
-     "endmodule\n"},
-    {"  module bar;for(genvar i = 0 ; i!=N ; i ++  ) begin "
-     "foo f;end endmodule\n",
-     "module bar;\n"
-     "  for (genvar i = 0; i != N; i++) begin\n"
-     "    foo f;\n"
-     "  end\n"
-     "endmodule\n"},
-    {
-        "module block_generate;\n"
-        "`ASSERT(blah)\n"
-        "generate endgenerate endmodule\n",
-        "module block_generate;\n"
-        "  `ASSERT(blah)\n"
-        "  generate\n"
-        "  endgenerate\n"
-        "endmodule\n",
-    },
-    {
-        "module conditional_generate;\n"
-        "if(foo)  ; \t"  // null action
-        "endmodule\n",
-        "module conditional_generate;\n"
-        "  if (foo);\n"
-        "endmodule\n",
-    },
-    {
-        "module conditional_generate;\n"
-        "if(foo[a*b+c])  ; \t"  // null action
-        "endmodule\n",
-        "module conditional_generate;\n"
-        "  if (foo[a*b+c]);\n"  // allow compact expressions inside []
-        "endmodule\n",
-    },
-    {
-        "module conditional_generate;\n"
-        "if(foo)begin\n"
-        "`ASSERT()\n"
-        "`COVER()\n"
-        " end\n"
-        "endmodule\n",
-        "module conditional_generate;\n"
-        "  if (foo) begin\n"
-        "    `ASSERT()\n"
-        "    `COVER()\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module conditional_generate;\n"
-        "`ASSERT()\n"
-        "if(foo)begin\n"
-        " end\n"
-        "`COVER()\n"
-        "endmodule\n",
-        "module conditional_generate;\n"
-        "  `ASSERT()\n"
-        "  if (foo) begin\n"
-        "  end\n"
-        "  `COVER()\n"
-        "endmodule\n",
-    },
-    {
-        "module conditional_generate;\n"
-        "if(foo)begin\n"
-        "           // comment1\n"
-        " // comment2\n"
-        " end\n"
-        "endmodule\n",
-        "module conditional_generate;\n"
-        "  if (foo) begin\n"
-        "    // comment1\n"
-        "    // comment2\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;"
-        "for(genvar i=0; ;)\n; "   // null generate statement
-        "for(genvar j=0 ;; )\n; "  // null generate statement
-        "endmodule",
-        "module m;\n"
-        "  for (genvar i = 0;;);\n"
-        "  for (genvar j = 0;;);\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;"
-        "for (genvar f = 0; f < N; f++) begin "
-        "assign x = y; assign y = z;"
-        "end endmodule",
-        "module m;\n"
-        "  for (genvar f = 0; f < N; f++) begin\n"
-        "    assign x = y;\n"
-        "    assign y = z;\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        // standalone genvar statement
-        "module m ;"
-        "genvar f;"
-        "for(f=0; f<N; f ++ )begin "
-        "end endmodule",
-        "module m;\n"
-        "  genvar f;\n"
-        "  for (f = 0; f < N; f++) begin\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        // multiple arguments to genvar statement
-        "module m ;"
-        "genvar f, g;"
-        "for(f=0; f<N; f ++ )begin "
-        "end for(g=N; g>0; g -- )begin "
-        "end endmodule",
-        "module m;\n"
-        "  genvar f, g;\n"
-        "  for (f = 0; f < N; f++) begin\n"
-        "  end\n"
-        "  for (g = N; g > 0; g--) begin\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        // multiple genvar statements
-        "module m ;"
-        "genvar f;"
-        "genvar g;"
-        "for(f=0; f<N; f ++ )begin "
-        "end for(g=N; g>0; g -- )begin "
-        "end endmodule",
-        "module m;\n"
-        "  genvar f;\n"
-        "  genvar g;\n"
-        "  for (f = 0; f < N; f++) begin\n"
-        "  end\n"
-        "  for (g = N; g > 0; g--) begin\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module event_control ;"
-        "always@ ( posedge   clk )z<=y;"
-        "endmodule\n",
-        "module event_control;\n"
-        "  always @(posedge clk) z <= y;\n"
-        "endmodule\n",
-    },
-    {
-        "module always_if ;"
-        "always@ ( posedge   clk ) if (expr) z<=y;"
-        "endmodule\n",
-        "module always_if;\n"
-        "  always @(posedge clk)\n"  // doesn't fit
-        "    if (expr)\n"
-        "      z <= y;\n"
-        "endmodule\n",
-    },
-    {
-        "module always_if ;"
-        "always@*  if (expr) z<=y;"
-        "endmodule\n",
-        "module always_if;\n"
-        "  always @* if (expr) z <= y;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else ;"
-        "always@*  if (expr) z<=y; else g<=0;"
-        "endmodule\n",
-        "module always_if_else;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"  // fits
-        "    else g <= 0;\n"       // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else_if ;"
-        "always@*  if (expr) z<=y; else if (w) g<=0;"
-        "endmodule\n",
-        "module always_if_else_if;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"    // fits
-        "    else if (w) g <= 0;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else_if_else ;"
-        "always@*  if (expr) z<=y; else if (w) g<=0;else h<=1;"
-        "endmodule\n",
-        "module always_if_else_if_else;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"    // fits
-        "    else if (w) g <= 0;\n"  // fits
-        "    else h <= 1;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(b,  c)"
-        "  for (;;)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(b, c) for (;;) s = y;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  for (i=0;i<k;++i)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    for (i = 0; i < k; ++i)\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  repeat (jj+kk)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    repeat (jj + kk)\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  foreach(jj[kk])\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    foreach (jj[kk])\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  while(jj[kk])\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    while (jj[kk])\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  do s=y;while(jj[kk]);\t"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    do\n"
-        "      s = y;\n"
-        "    while (jj[kk]);\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)  \n"
-        "  case(jj)\tS:s = y;endcase\t"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    case (jj)\n"
-        "      S: s = y;\n"
-        "    endcase\n"
-        "endmodule\n",
-    },
-
-    {
-        "module always_if ;"
-        "always@ ( posedge   clk ) if (expr) z<=y;"
-        "endmodule\n",
-        "module always_if;\n"
-        "  always @(posedge clk)\n"  // doesn't fit
-        "    if (expr)\n"
-        "      z <= y;\n"
-        "endmodule\n",
-    },
-    {
-        "module always_if ;"
-        "always@*  if (expr) z<=y;"
-        "endmodule\n",
-        "module always_if;\n"
-        "  always @* if (expr) z <= y;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else ;"
-        "always@*  if (expr) z<=y; else g<=0;"
-        "endmodule\n",
-        "module always_if_else;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"  // fits
-        "    else g <= 0;\n"       // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else_if ;"
-        "always@*  if (expr) z<=y; else if (w) g<=0;"
-        "endmodule\n",
-        "module always_if_else_if;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"    // fits
-        "    else if (w) g <= 0;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else_if_else ;"
-        "always@*  if (expr) z<=y; else if (w) g<=0;else h<=1;"
-        "endmodule\n",
-        "module always_if_else_if_else;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"    // fits
-        "    else if (w) g <= 0;\n"  // fits
-        "    else h <= 1;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(b,  c)"
-        "  for (;;)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(b, c) for (;;) s = y;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  for (i=0;i<k;++i)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    for (i = 0; i < k; ++i)\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  repeat (jj+kk)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    repeat (jj + kk)\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  foreach(jj[kk])\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    foreach (jj[kk])\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  while(jj[kk])\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    while (jj[kk])\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  do s=y;while(jj[kk]);\t"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    do\n"
-        "      s = y;\n"
-        "    while (jj[kk]);\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)  \n"
-        "  case(jj)\tS:s = y;endcase\t"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    case (jj)\n"
-        "      S: s = y;\n"
-        "    endcase\n"
-        "endmodule\n",
-    },
-
-    {
-        "module always_if ;"
-        "always@ ( posedge   clk ) if (expr) z<=y;"
-        "endmodule\n",
-        "module always_if;\n"
-        "  always @(posedge clk)\n"  // doesn't fit
-        "    if (expr)\n"
-        "      z <= y;\n"
-        "endmodule\n",
-    },
-    {
-        "module always_if ;"
-        "always@*  if (expr) z<=y;"
-        "endmodule\n",
-        "module always_if;\n"
-        "  always @* if (expr) z <= y;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else ;"
-        "always@*  if (expr) z<=y; else g<=0;"
-        "endmodule\n",
-        "module always_if_else;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"  // fits
-        "    else g <= 0;\n"       // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else_if ;"
-        "always@*  if (expr) z<=y; else if (w) g<=0;"
-        "endmodule\n",
-        "module always_if_else_if;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"    // fits
-        "    else if (w) g <= 0;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else_if_else ;"
-        "always@*  if (expr) z<=y; else if (w) g<=0;else h<=1;"
-        "endmodule\n",
-        "module always_if_else_if_else;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"    // fits
-        "    else if (w) g <= 0;\n"  // fits
-        "    else h <= 1;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(b,  c)"
-        "  for (;;)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(b, c) for (;;) s = y;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  for (i=0;i<k;++i)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    for (i = 0; i < k; ++i)\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  repeat (jj+kk)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    repeat (jj + kk)\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  foreach(jj[kk])\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    foreach (jj[kk])\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  while(jj[kk])\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    while (jj[kk])\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  do s=y;while(jj[kk]);\t"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    do\n"
-        "      s = y;\n"
-        "    while (jj[kk]);\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)  \n"
-        "  case(jj)\tS:s = y;endcase\t"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    case (jj)\n"
-        "      S: s = y;\n"
-        "    endcase\n"
-        "endmodule\n",
-    },
-
-    {
-        "module always_if ;"
-        "always@ ( posedge   clk ) if (expr) z<=y;"
-        "endmodule\n",
-        "module always_if;\n"
-        "  always @(posedge clk)\n"  // doesn't fit
-        "    if (expr)\n"
-        "      z <= y;\n"
-        "endmodule\n",
-    },
-    {
-        "module always_if ;"
-        "always@*  if (expr) z<=y;"
-        "endmodule\n",
-        "module always_if;\n"
-        "  always @* if (expr) z <= y;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else ;"
-        "always@*  if (expr) z<=y; else g<=0;"
-        "endmodule\n",
-        "module always_if_else;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"  // fits
-        "    else g <= 0;\n"       // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else_if ;"
-        "always@*  if (expr) z<=y; else if (w) g<=0;"
-        "endmodule\n",
-        "module always_if_else_if;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"    // fits
-        "    else if (w) g <= 0;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module \talways_if_else_if_else ;"
-        "always@*  if (expr) z<=y; else if (w) g<=0;else h<=1;"
-        "endmodule\n",
-        "module always_if_else_if_else;\n"
-        "  always @*\n"
-        "    if (expr) z <= y;\n"    // fits
-        "    else if (w) g <= 0;\n"  // fits
-        "    else h <= 1;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(b,  c)"
-        "  for (;;)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(b, c) for (;;) s = y;\n"  // fits
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  for (i=0;i<k;++i)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    for (i = 0; i < k; ++i)\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  repeat (jj+kk)\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    repeat (jj + kk)\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  foreach(jj[kk])\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    foreach (jj[kk])\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  while(jj[kk])\ts = y;"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    while (jj[kk])\n"
-        "      s = y;\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)"
-        "  do s=y;while(jj[kk]);\t"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    do\n"
-        "      s = y;\n"
-        "    while (jj[kk]);\n"
-        "endmodule\n",
-    },
-    {
-        "module m;\n"
-        "always @(posedge clk)  \n"
-        "  case(jj)\tS:s = y;endcase\t"
-        "endmodule",
-        "module m;\n"
-        "  always @(posedge clk)\n"
-        "    case (jj)\n"
-        "      S: s = y;\n"
-        "    endcase\n"
-        "endmodule\n",
-    },
-
-    {
-        // begin/end with labels
-        "module m ;initial  begin:yyy\tend:yyy endmodule",
-        "module m;\n"
-        "  initial begin : yyy\n"
-        "  end : yyy\n"
-        "endmodule\n",
-    },
-    {
-        // conditional generate begin/end with labels
-        "module m ;if\n( 1)  begin:yyy\tend:yyy endmodule",
-        "module m;\n"
-        "  if (1) begin : yyy\n"
-        "  end : yyy\n"
-        "endmodule\n",
-    },
-    {
-        // begin/end with labels, nested
-        "module m ;initial  begin:yyy if(1)begin:zzz "
-        "end:zzz\tend:yyy endmodule",
-        "module m;\n"
-        "  initial begin : yyy\n"
-        "    if (1) begin : zzz\n"
-        "    end : zzz\n"
-        "  end : yyy\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;initial  begin #  1 x<=y ;end endmodule",
-        "module m;\n"
-        "  initial begin\n"
-        "    #1 x <= y;\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;initial  begin x<=y ;  y<=z;end endmodule",
-        "module m;\n"
-        "  initial begin\n"
-        "    x <= y;\n"
-        "    y <= z;\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;initial  begin # 10 x<=y ;  # 20  y<=z;end endmodule",
-        "module m;\n"
-        "  initial begin\n"
-        "    #10 x <= y;\n"
-        "    #20 y <= z;\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        // qualified variables
-        "module m ;initial  begin automatic int a; "
-        " static byte s=0;end endmodule",
-        "module m;\n"
-        "  initial begin\n"
-        "    automatic int a;\n"
-        "    static byte   s = 0;\n"  // aligned
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;initial  begin automatic int a,b; "
-        " static byte s,t;end endmodule",
-        "module m;\n"
-        "  initial begin\n"
-        "    automatic int a, b;\n"
-        "    static byte s, t;\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;initial  begin   static byte a=1,b=0;end endmodule",
-        "module m;\n"
-        "  initial begin\n"
-        "    static byte a = 1, b = 0;\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;initial  begin   const int a=0;end endmodule",
-        "module m;\n"
-        "  initial begin\n"
-        "    const int a = 0;\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;initial  begin automatic   const int a=0;end endmodule",
-        "module m;\n"
-        "  initial begin\n"
-        "    automatic const int a = 0;\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;initial  begin const  var automatic  int a=0;end endmodule",
-        "module m;\n"
-        "  initial begin\n"
-        "    const var automatic int a = 0;\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;initial  begin static byte s  ={<<{a}};end endmodule",
-        "module m;\n"
-        "  initial begin\n"
-        "    static byte s = {<<{a}};\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m ;initial  begin static int s  ={>>4{a}};end endmodule",
-        "module m;\n"
-        "  initial begin\n"
-        "    static int s = {>>4{a}};\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m; final  assert   (expr ) ;endmodule",
-        "module m;\n"
-        "  final assert (expr);\n"
-        "endmodule\n",
-    },
-    {
-        "module m; final  begin\tassert   (expr ) ;end  endmodule",
-        "module m;\n"
-        "  final begin\n"
-        "    assert (expr);\n"
-        "  end\n"
-        "endmodule\n",
-    },
-    {
-        "module m; final  assume   (expr ) ;endmodule",
-        "module m;\n"
-        "  final assume (expr);\n"
-        "endmodule\n",
-    },
-    {
-        "module m; final  cover   (expr ) ;endmodule",
-        "module m;\n"
-        "  final cover (expr);\n"
-        "endmodule\n",
-    },
-    {
-        // two consecutive clocking declarations in modules
-        " module mcd ; "
-        "clocking   cb @( posedge clk);\t\tendclocking "
-        "clocking cb2   @ (posedge  clk\n); endclocking endmodule",
-        "module mcd;\n"
-        "  clocking cb @(posedge clk);\n"
-        "  endclocking\n"
-        "  clocking cb2 @(posedge clk);\n"
-        "  endclocking\n"
-        "endmodule\n",
-    },
-    {
-        // two consecutive clocking declarations in modules, with end labels
-        " module mcd ; "
-        "clocking   cb @( posedge clk);\t\tendclocking:  cb "
-        "clocking cb2   @ (posedge  clk\n); endclocking   :cb2 endmodule",
-        "module mcd;\n"
-        "  clocking cb @(posedge clk);\n"
-        "  endclocking : cb\n"
-        "  clocking cb2 @(posedge clk);\n"
-        "  endclocking : cb2\n"
-        "endmodule\n",
-    },
-    {
-        // clocking declarations with ports in modules
-        " module mcd ; "
-        "clocking cb   @ (posedge  clk\n); input a; output b; endclocking "
-        "endmodule",
-        "module mcd;\n"
-        "  clocking cb @(posedge clk);\n"
-        "    input a;\n"
-        "    output b;\n"
-        "  endclocking\n"
-        "endmodule\n",
-    },
-    {
-        // DPI import declarations in modules
-        "module mdi;"
-        "import   \"DPI-C\" function  int add(\n) ;"
-        "import \"DPI-C\"\t\tfunction int\nsleep( input int secs );"
-        "import \"DPI-C\"\t\tfunction int\nwake( input int secs, output bit "
-        "[2:0] z);"
-        "endmodule",
-        "module mdi;\n"
-        "  import \"DPI-C\" function int add();\n"
-        "  import \"DPI-C\" function int sleep(\n"
-        "    input int secs\n"
-        "  );\n"
-        "  import \"DPI-C\" function int wake(\n"
-        "    input  int       secs,\n"
-        "    output bit [2:0] z\n"
-        "  );\n"
-        "endmodule\n",
-    },
-    {
-        // DPI export declarations in modules
-        "module m;"
-        "export \"DPI-C\" function get;"
-        "export \"DPI-C\" function mhpmcounter_get;\n"
-        "export \"DPI-C\"\t\tfunction int\nwake( input int secs, output bit "
-        "[2:0] z);"
-        "endmodule",
-        "module m;\n"
-        "  export \"DPI-C\" function get;\n"
-        "  export \"DPI-C\"\n"
-        "      function mhpmcounter_get;\n"  // doesn't fit in 40-col
-        "  export \"DPI-C\" function int wake(\n"
-        "    input  int       secs,\n"
-        "    output bit [2:0] z\n"
-        "  );\n"
-        "endmodule\n",
-    },
-    {// Two consecutive EOL comments in kDPIImportItem
-     "import \"DPI-C\" context function void foo(\n"
-     "  input bit first,\n"
-     "  // c3\n"
-     "  // c3+\n"
-     "  input bit second\n"
-     ");\n",
-     "import \"DPI-C\" context\n"
-     "    function void foo(\n"
-     "  input bit first,\n"
-     "  // c3\n"
-     "  // c3+\n"
-     "  input bit second\n"
-     ");\n"},
-    {"export \"\" t;\n", "export \"\" t;\n"},
-    {"import \"DPI-C\" context function void func(input bit impl_i,"
-     "input bit op_i,"
-     "input bit [5:0] mode_i,"
-     "input bit [3:0][31:0] iv_i,"
-     "input bit [2:0] key_len_i,"
-     "input bit [7:0][31:0] key_i,"
-     "input bit [7:0] data_i[],"
-     "output bit [7:0] data_o[]);",
-     "import \"DPI-C\" context\n"
-     "    function void func(\n"
-     "  input  bit             impl_i,\n"
-     "  input  bit             op_i,\n"
-     "  input  bit [5:0]       mode_i,\n"
-     "  input  bit [3:0][31:0] iv_i,\n"
-     "  input  bit [2:0]       key_len_i,\n"
-     "  input  bit [7:0][31:0] key_i,\n"
-     "  input  bit [7:0]       data_i   [],\n"
-     "  output bit [7:0]       data_o   []\n"
-     ");\n"},
-    {// module with system task call w or w/o parentheses
-     "module m; initial begin #10 $display(\"foo\"); $display(\"bar\");"
-     "end endmodule",
-     "module m;\n"
-     "  initial begin\n"
-     "    #10 $display(\"foo\");\n"
-     "    $display(\"bar\");\n"
-     "  end\n"
-     "endmodule\n"},
-    {// module with system task call
-     "module m; initial begin #10 $display; $display;"
-     "end endmodule",
-     "module m;\n"
-     "  initial begin\n"
-     "    #10 $display;\n"
-     "    $display;\n"
-     "  end\n"
-     "endmodule\n"},
-
-    // interface test cases
-    {// two interface declarations
-     " interface if1 ; endinterface\t\t"
-     "interface  if2; endinterface   ",
-     "interface if1;\n"
-     "endinterface\n"
-     "interface if2;\n"
-     "endinterface\n"},
-    {// two interface declarations, end labels
-     " interface if1 ; endinterface:if1\t\t"
-     "interface  if2; endinterface    :  if2   ",
-     "interface if1;\n"
-     "endinterface : if1\n"
-     "interface if2;\n"
-     "endinterface : if2\n"},
-    {// interface declaration with parameters
-     " interface if1#( parameter int W= 8 );endinterface\t\t",
-     "interface if1 #(\n"
-     "    parameter int W = 8\n"
-     ");\n"
-     "endinterface\n"},
-    {// interface declaration with ports (empty)
-     " interface if1()\n;endinterface\t\t",
-     "interface if1 ();\n"
-     "endinterface\n"},
-    {// interface declaration with parameter comment only, empty ports
-     " interface if1#( \n"
-     "//param\n"
-     ")();endinterface\t\t",
-     "interface if1 #(\n"
-     "    //param\n"
-     ") ();\n"
-     "endinterface\n"},
-    {// interface declaration with parameter, empty ports
-     " interface if1#( parameter int W= 8 )();endinterface\t\t",
-     "interface if1 #(\n"
-     "    parameter int W = 8\n"
-     ") ();\n"
-     "endinterface\n"},
-    {// interface declaration with ports
-     " interface if1( input\tlogic   z)\n;endinterface\t\t",
-     "interface if1 (\n"
-     "    input logic z\n"
-     ");\n"
-     "endinterface\n"},
-    {// interface declaration with multiple ports
-     " interface if1( input\tlogic   z, output logic a)\n;endinterface\t\t",
-     "interface if1 (\n"
-     "    input  logic z,\n"  // should be one-per-line, even it it fits
-     "    output logic a\n"   // aligned
-     ");\n"
-     "endinterface\n"},
-    {// interface declaration with parameters and ports
-     " interface if1#( parameter int W= 8 )(input logic z);endinterface\t\t",
-     // doesn't fit on one line
-     "interface if1 #(\n"
-     "    parameter int W = 8\n"
-     ") (\n"
-     "    input logic z\n"
-     ");\n"
-     "endinterface\n"},
-    {
-        // interface with modport declarations
-        "interface\tfoo_if  ;"
-        "modport  mp1\t( output a, input b);"
-        "modport\tmp2  (output c,input d );\t"
-        "endinterface",
-        "interface foo_if;\n"
-        "  modport mp1(output a, input b);\n"
-        "  modport mp2(output c, input d);\n"
-        "endinterface\n",
-    },
-    {
-        // interface with long modport port names
-        "interface\tfoo_if  ;"
-        "modport  mp1\t( output a_long_output, input detailed_input_name);"
-        "endinterface",
-        "interface foo_if;\n"
-        "  modport mp1(\n"
-        "      output a_long_output,\n"
-        "      input detailed_input_name\n"
-        "  );\n"
-        "endinterface\n",
-    },
-    {
-        // interface with modport declaration with multiple ports
-        "interface\tfoo_if  ;"
-        "modport  mp1\t( output a_long_output, input detailed_input_name);"
-        "endinterface",
-        "interface foo_if;\n"
-        "  modport mp1(\n"
-        "      output a_long_output,\n"
-        "      input detailed_input_name\n"
-        "  );\n"
-        "endinterface\n",
-    },
-    {
-        // interface with modport TF port declaration
-        "interface\tfoo_if  ;"
-        "modport  mp1\t( output a, input b, import c);"
-        "endinterface",
-        "interface foo_if;\n"
-        "  modport mp1(\n"
-        "      output a,\n"
-        "      input b,\n"
-        "      import c\n"
-        "  );\n"
-        "endinterface\n",
-    },
-    {
-        // interface with complex modport ports list
-        "interface\tfoo_if  ;"
-        "modport producer\t(input ready,\toutput data, valid, user,"
-        " strobe, keep, last,\timport producer_reset, producer_tick);"
-        "modport consumer\t(input data, valid, user, strobe, keep, last,"
-        " output ready,\timport consumer_reset, consumer_tick, consume);"
-        "endinterface",
-        "interface foo_if;\n"
-        "  modport producer(\n"
-        "      input ready,\n"
-        "      output data, valid, user, strobe,\n"
-        "          keep, last,\n"
-        "      import producer_reset,\n"
-        "          producer_tick\n"
-        "  );\n"
-        "  modport consumer(\n"
-        "      input data, valid, user, strobe,\n"
-        "          keep, last,\n"
-        "      output ready,\n"
-        "      import consumer_reset,\n"
-        "          consumer_tick, consume\n"
-        "  );\n"
-        "endinterface\n",
-    },
-    {
-        // interface with modports and comments inside
-        "interface foo_if;\n"
-        " modport mp1(\n"
-        "  // Our output\n"
-        "     output a,\n"
-        "  /* Inputs */\n"
-        "      input b1, b_f /*last*/,"
-        "  import c\n"
-        "  );\n"
-        "endinterface\n",
-        "interface foo_if;\n"
-        "  modport mp1(\n"
-        "      // Our output\n"
-        "      output a,\n"
-        "      /* Inputs */\n"
-        "      input b1, b_f  /*last*/,\n"
-        "      import c\n"
-        "  );\n"
-        "endinterface\n",
-    },
-
-    // class test cases
-    {"class action;int xyz;endclass  :  action\n",
-     "class action;\n"
-     "  int xyz;\n"
-     "endclass : action\n"},
-    {"class action  extends mypkg :: inaction;endclass  :  action\n",
-     "class action extends mypkg::inaction;\n"  // tests for spacing around ::
-     "endclass : action\n"},
-    {"class c;function new;endfunction endclass",
-     "class c;\n"
-     "  function new;\n"
-     "  endfunction\n"
-     "endclass\n"},
-    {"class c;function new ( );endfunction endclass",
-     "class c;\n"
-     "  function new();\n"
-     "  endfunction\n"
-     "endclass\n"},
-    {"class c;function new ( string s );endfunction endclass",
-     "class c;\n"
-     "  function new(string s);\n"
-     "  endfunction\n"
-     "endclass\n"},
-    {"class c;function new ( string s ,int i );endfunction endclass",
-     "class c;\n"
-     "  function new(string s, int i);\n"
-     "  endfunction\n"
-     "endclass\n"},
-    {"class c;function void f;endfunction endclass",
-     "class c;\n"
-     "  function void f;\n"
-     "  endfunction\n"
-     "endclass\n"},
-    {"class c;virtual function void f;endfunction endclass",
-     "class c;\n"
-     "  virtual function void f;\n"
-     "  endfunction\n"
-     "endclass\n"},
-    {"class c;function int f ( );endfunction endclass",
-     "class c;\n"
-     "  function int f();\n"
-     "  endfunction\n"
-     "endclass\n"},
-    {"class c;function int f ( int  ii );endfunction endclass",
-     "class c;\n"
-     "  function int f(int ii);\n"
-     "  endfunction\n"
-     "endclass\n"},
-    {"class c;function int f ( int  ii ,bit  bb );endfunction endclass",
-     "class c;\n"
-     "  function int f(int ii, bit bb);\n"
-     "  endfunction\n"
-     "endclass\n"},
-    {"class c;task t ;endtask endclass",
-     "class c;\n"
-     "  task t;\n"
-     "  endtask\n"
-     "endclass\n"},
-    {"class c;task t ( int  ii ,bit  bb );endtask endclass",
-     "class c;\n"
-     "  task t(int ii, bit bb);\n"
-     "  endtask\n"
-     "endclass\n"},
-    {"class c; task automatic repeated_assigner;"
-     "repeat (count) y = w;"  // single statement body
-     "endtask endclass",
-     "class c;\n"
-     "  task automatic repeated_assigner;\n"
-     "    repeat (count) y = w;\n"
-     "  endtask\n"
-     "endclass\n"},
-    {"class c; task automatic delayed_assigner;"
-     "#   100   y = w;"  // delayed assignment
-     "endtask endclass",
-     "class c;\n"
-     "  task automatic delayed_assigner;\n"
-     "    #100 y = w;\n"
-     "  endtask\n"
-     "endclass\n"},
-    {"class c; task automatic labeled_assigner;"
-     "lbl   :   y = w;"  // delayed assignment
-     "endtask endclass",
-     "class c;\n"
-     "  task automatic labeled_assigner;\n"
-     "    lbl : y = w;\n"  // TODO(fangism): no space before ':'
-     "  endtask\n"
-     "endclass\n"},
-    // task with macro call
-    {"module m1;\ntask automatic t1();\n"
-     "t2(`R1(1)+ 8);endtask : t1\nendmodule",
-     "module m1;\n"
-     "  task automatic t1();\n"
-     "    t2(`R1(1) + 8);\n"
-     "  endtask : t1\n"
-     "endmodule\n"},
-
-    // tasks with control statements
-    {"class c; task automatic waiter;"
-     "if (count == 0) begin #0; return;end "
-     "endtask endclass",
-     "class c;\n"
-     "  task automatic waiter;\n"
-     "    if (count == 0) begin\n"
-     "      #0;\n"
-     "      return;\n"
-     "    end\n"
-     "  endtask\n"
-     "endclass\n"},
-    {"class c; task automatic heartbreaker;"
-     "if( c)if( d) break ;"
-     "endtask endclass",
-     "class c;\n"
-     "  task automatic heartbreaker;\n"
-     "    if (c) if (d) break;\n"
-     "  endtask\n"
-     "endclass\n"},
-    {"class c; task automatic waiter;"
-     "repeat (count) @(posedge clk);"
-     "endtask endclass",
-     "class c;\n"
-     "  task automatic waiter;\n"
-     "    repeat (count) @(posedge clk);\n"
-     "  endtask\n"
-     "endclass\n"},
-    {"class c; task automatic repeat_assigner;"
-     "repeat( r )\ny = w;"
-     "repeat( q )\ny = 1;"
-     "endtask endclass",
-     "class c;\n"
-     "  task automatic repeat_assigner;\n"
-     "    repeat (r) y = w;\n"
-     "    repeat (q) y = 1;\n"
-     "  endtask\n"
-     "endclass\n"},
-    {"class c; task automatic event_control_assigner;"
-     "@ ( posedge clk )\ny = w;"
-     "@ ( negedge clk )\nz = w;"
-     "endtask endclass",
-     "class c;\n"
-     "  task automatic event_control_assigner;\n"
-     "    @(posedge clk) y = w;\n"
-     "    @(negedge clk) z = w;\n"
-     "  endtask\n"
-     "endclass\n"},
-    {
-        // classes with surrrounding comments
-        // vertical spacing preserved
-        "\n// pre-c\n\n"
-        "  class   c  ;\n"
-        "// c stuff\n"
-        "endclass\n"
-        "  // pre-d\n"
-        "\n\nclass d ;\n"
-        " // d stuff\n"
-        "endclass\n"
-        "\n// the end\n",
-        "\n// pre-c\n\n"
-        "class c;\n"
-        "  // c stuff\n"
-        "endclass\n"
-        "// pre-d\n\n\n"
-        "class d;\n"
-        "  // d stuff\n"
-        "endclass\n\n"
-        "// the end\n",
-    },
-    {// class with comments around task/function declarations
-     "class c;      // c is for cookie\n"
-     "    // f is for false\n"
-     "\tfunction f(integer size) ; endfunction\n"
-     " // t is for true\n"
-     "task t();endtask\n"
-     " // class is about to end\n"
-     "endclass",
-     "class c;  // c is for cookie\n"
-     "  // f is for false\n"
-     "  function f(integer size);\n"
-     "  endfunction\n"
-     "  // t is for true\n"
-     "  task t();\n"
-     "  endtask\n"
-     "  // class is about to end\n"
-     "endclass\n"},
-
-    // interface class test cases
-    {"interface class Foo;\nendclass\n",
-     "interface class Foo;\n"
-     "endclass\n"},
-    {"interface   class   Foo  ;  endclass\n",
-     "interface class Foo;\n"
-     "endclass\n"},
-    {"interface class Foo extends Bar , Baz ;\nendclass\n",
-     "interface class Foo extends Bar, Baz;\n"
-     "endclass\n"},
-    {"interface class Foo;\n  pure   virtual   task   foo (  ) ; \nendclass\n",
-     "interface class Foo;\n"
-     "  pure virtual task foo();\n"
-     "endclass\n"},
-
-    // class property alignment test cases
-    {"class c;\n"
-     "int foo  ;\n"
-     "byte bar;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  int  foo;\n"
-     "  byte bar;\n"
-     "endclass : c\n"},
-    {"class c;\n"
-     "int foo;\n"
-     "const bit b;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  int       foo;\n"
-     "  const bit b;\n"
-     "endclass : c\n"},
-    {"class c;\n"
-     "rand logic l;\n"
-     "int foo;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  rand logic l;\n"
-     "  int        foo;\n"
-     "endclass : c\n"},
-    {"class c;\n"
-     "rand logic l;\n"
-     "const static int foo;\n"  // more qualifiers
-     "endclass : c\n",
-     "class c;\n"
-     "  rand logic       l;\n"
-     "  const static int foo;\n"
-     "endclass : c\n"},
-    {"class c;\n"
-     "static local int foo;\n"
-     "const bit b;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  static local int foo;\n"
-     "  const bit        b;\n"
-     "endclass : c\n"},
-    {// example with queue
-     "class c;\n"
-     "int foo [$] ;\n"
-     "int foo_bar ;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  int foo     [$];\n"
-     "  int foo_bar;\n"
-     "endclass : c\n"},
-    {// subcolumns
-     "class cc;\n"
-     "rand bit [A-1:0] foo;\n"
-     "rand bit [A-1:0][2] bar;\n"
-     "int foobar[X+1:Y];\n"
-     "int baz[42];\n"
-     "rand bit qux[Z];\n"
-     "rand bit [1:0] quux[3:0];\n"
-     "rand bit [A:BB][42] quuz[7];\n"
-     "endclass\n",
-     "class cc;\n"
-     "  rand bit [A-1: 0]     foo;\n"
-     "  rand bit [A-1: 0][ 2] bar;\n"
-     "  int                   foobar[X+1:Y];\n"
-     "  int                   baz   [   42];\n"
-     "  rand bit              qux   [    Z];\n"
-     "  rand bit [  1: 0]     quux  [  3:0];\n"
-     "  rand bit [  A:BB][42] quuz  [    7];\n"
-     "endclass\n"},
-    {"class cc;\n"
-     "int qux[2];\n"
-     "int quux[SIZE-1+SHIFT:SHIFT];\n"
-     "int quuz[SOME_CONSTANT];\n"
-     "endclass\n",
-     "class cc;\n"
-     "  int qux [                 2];\n"
-     "  int quux[SIZE-1+SHIFT:SHIFT];\n"
-     "  int quuz[     SOME_CONSTANT];\n"
-     "endclass\n"},
-    {// aligns over comments (ignored)
-     "class c;\n"
-     "// foo is...\n"
-     "int foo;\n"
-     "// b is...\n"
-     "const bit b;\n"
-     " // llama is...\n"
-     "logic llama;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  // foo is...\n"
-     "  int       foo;\n"
-     "  // b is...\n"
-     "  const bit b;\n"
-     "  // llama is...\n"
-     "  logic     llama;\n"
-     "endclass : c\n"},
-    {// aligns over comments (ignored), even with blank lines
-     "class c;\n"
-     "// foo is...\n"
-     "int foo;\n"
-     "\n"
-     "// b is...\n"
-     "const bit b;\n"
-     "\n"
-     " // llama is...\n"
-     "logic llama;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  // foo is...\n"
-     "  int       foo;\n"
-     "\n"
-     "  // b is...\n"
-     "  const bit b;\n"
-     "\n"
-     "  // llama is...\n"
-     "  logic     llama;\n"
-     "endclass : c\n"},
-    {"class c;\n"
-     "rand logic l;\n"
-     "int [1:0] foo;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  rand logic       l;\n"
-     "  int        [1:0] foo;\n"
-     "endclass : c\n"},
-    {// non-data-declarations break up groups
-     "class c;\n"
-     "rand logic l;\n"
-     "int foo;\n"
-     "`uvm_bar_foo()\n"
-     "logic k;\n"
-     "rand int bar;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  rand logic l;\n"
-     "  int        foo;\n"
-     "  `uvm_bar_foo()\n"  // separates alignment groups above/below
-     "  logic    k;\n"
-     "  rand int bar;\n"
-     "endclass : c\n"},
-    {// non-data-declarations break up groups
-     "class c;\n"
-     "logic k;\n"
-     "rand int bar;\n"
-     "function void f();\n"
-     "endfunction\n"
-     "rand logic l;\n"
-     "int foo;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  logic    k;\n"
-     "  rand int bar;\n"
-     "  function void f();\n"  // function declaration breaks groups
-     "  endfunction\n"
-     "  rand logic l;\n"
-     "  int        foo;\n"
-     "endclass : c\n"},
-    {// align single-value initializers at the '='
-     "class c;\n"
-     "const logic foo=0;\n"
-     "const bit b=1;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  const logic foo = 0;\n"
-     "  const bit   b   = 1;\n"
-     "endclass : c\n"},
-    {// align single-value initializers at the '=', over non-initialized
-     "class c;\n"
-     "const logic foo=0;\n"
-     "rand int iidrv;\n"
-     "const bit b=1;\n"
-     "endclass : c\n",
-     "class c;\n"
-     "  const logic foo    = 0;\n"
-     "  rand int    iidrv;\n"  // no initializer, but align across this
-     "  const bit   b      = 1;\n"
-     "endclass : c\n"},
-
-    // constraint test cases
-    {
-        "class foo; constraint c1_c{ } endclass",
-        "class foo;\n"
-        "  constraint c1_c {}\n"
-        "endclass\n",
-    },
-    {
-        "class foo; constraint c1_c{  } constraint c2_c{ } endclass",
-        "class foo;\n"
-        "  constraint c1_c {}\n"
-        "  constraint c2_c {}\n"
-        "endclass\n",
-    },
-    {
-        "class foo; constraint c1_c{soft z==y;unique{baz};}endclass",
-        "class foo;\n"
-        "  constraint c1_c {\n"
-        "    soft z == y;\n"
-        "    unique {baz};\n"
-        "  }\n"
-        "endclass\n",
-    },
-    {
-        "class foo; constraint c1_c{ //comment1\n"
-        "//comment2\n"
-        "//comment3\n"
-        "} endclass",
-        "class foo;\n"
-        "  constraint c1_c {  //comment1\n"
-        "    //comment2\n"
-        "    //comment3\n"
-        "  }\n"
-        "endclass\n",
-    },
-
-    {"class foo;constraint c { "
-     "timer_enable dist { [ 8'h0 : 8'hfe ] :/ 90 , 8'hff :/ 10 }; "
-     "} endclass\n",
-     "class foo;\n"
-     "  constraint c {\n"
-     "    timer_enable dist {\n"
-     "      [8'h0 : 8'hfe] :/ 90,\n"
-     "      8'hff          :/ 10\n"  // aligned
-     "    };\n"
-     "  }\n"
-     "endclass\n"},
-
-    {
-        "class Foo; constraint if_c { if (z) { soft x == y; } } endclass\n",
-        "class Foo;\n"
-        "  constraint if_c {\n"
-        "    if (z) {\n"
-        "      soft x == y;\n"
-        "    }\n"
-        "  }\n"
-        "endclass\n",
-    },
-    {
-        "class Foo; constraint if_c { if (z) {\n"
-        "//comment-a\n"
-        "soft x == y;\n"
-        "//comment-b\n"
-        "} } endclass\n",
-        "class Foo;\n"
-        "  constraint if_c {\n"
-        "    if (z) {\n"
-        "      //comment-a\n"  // properly indented
-        "      soft x == y;\n"
-        "      //comment-b\n"  // properly indented
-        "    }\n"
-        "  }\n"
-        "endclass\n",
-    },
-    {
-        "class c; "
-        "constraint c_has_config_error {"
-        "if (yyy) {zzzz == 1;} else {yyyyyyy == 0;}} "
-        "endclass",
-        "class c;\n"
-        "  constraint c_has_config_error {\n"
-        "    if (yyy) {\n"
-        "      zzzz == 1;\n"
-        "    } else {\n"
-        "      yyyyyyy == 0;\n"
-        "    }\n"
-        "  }\n"
-        "endclass\n",
-    },
-    // distributions: colon alignment
-    {"class c;\n"
-     "constraint co {\n"
-     "d dist {\n"
-     "[1:2]:/2,\n"
-     "[11:33]:/22,\n"
-     "[111:444]:/8,\n"
-     "[1:42]:/10,\n"
-     "[11:12]:/3\n"
-     "};\n"
-     "}\n"
-     "endclass\n",
-     "class c;\n"
-     "  constraint co {\n"
-     "    d dist {\n"
-     "      [  1 :   2] :/ 2,\n"
-     "      [ 11 :  33] :/ 22,\n"
-     "      [111 : 444] :/ 8,\n"
-     "      [  1 :  42] :/ 10,\n"
-     "      [ 11 :  12] :/ 3\n"
-     "    };\n"
-     "  }\n"
-     "endclass\n"},
-    // distributions: subcolumns
-    {"class foo;\n"
-     "constraint bar {\n"
-     "baz dist {\n"
-     "[1:2]:/2,\n"
-     "QUX[3:0]:/10,\n"
-     "[11:33]:/22,\n"
-     "ID_LONGER_THAN_RANGES:/3,\n"
-     "[111:QUUZ[Z]]:/8,\n"
-     "[X[4:0]:Y[8:Z-2]]:/8\n"
-     "};\n"
-     "}\n"
-     "endclass\n",
-     "class foo;\n"
-     "  constraint bar {\n"
-     "    baz dist {\n"
-     "      [     1 :        2]   :/ 2,\n"
-     "      QUX[3:0]              :/ 10,\n"
-     "      [    11 :       33]   :/ 22,\n"
-     "      ID_LONGER_THAN_RANGES :/ 3,\n"
-     "      [   111 :  QUUZ[Z]]   :/ 8,\n"
-     "      [X[4:0] : Y[8:Z-2]]   :/ 8\n"
-     "    };\n"
-     "  }\n"
-     "endclass\n"},
-    // class with empty parameter list
-    {"class foo #(); endclass",
-     "class foo #();\n"
-     "endclass\n"},
-    // class with empty parameter list, with comment
-    {"class foo #(  \n"
-     "// comment\n"
-     "); endclass",
-     "class foo #(\n"
-     "    // comment\n"
-     ");\n"
-     "endclass\n"},
-    // class with empty parameter list, extends
-    {"class foo #()extends bar ; endclass",
-     "class foo #() extends bar;\n"
-     "endclass\n"},
-    // class extends from type with named parameters
-    {"class foo extends bar #(.N(N), .M(M)); endclass",
-     "class foo extends bar #(\n"
-     "    .N(N),\n"
-     "    .M(M)\n"
-     ");\n"
-     "endclass\n"},
-
-    // class with one parameter list
-    {"class foo #(type a = b); endclass",
-     "class foo #(\n"
-     "    type a = b\n"
-     ");\n"
-     "endclass\n"},
-
-    // class with multiple paramter list
-    {"class foo #(type a = b, type c = d, type e = f); endclass",
-     "class foo #(\n"
-     "    type a = b,\n"
-     "    type c = d,\n"
-     "    type e = f\n"
-     ");\n"
-     "endclass\n"},
-
-    // class with data members
-    {"class  i_love_data ;const\ninteger  sizer\t;endclass",
-     "class i_love_data;\n"
-     "  const integer sizer;\n"
-     "endclass\n"},
-    {"class  i_love_data ;const\ninteger  sizer=3\t;endclass",
-     "class i_love_data;\n"
-     "  const integer sizer = 3;\n"
-     "endclass\n"},
-    {"class  i_love_data ;protected\nint  count  \t;endclass",
-     "class i_love_data;\n"
-     "  protected int count;\n"
-     "endclass\n"},
-    {"class  i_love_data ;\t\nint  counter\n ;int  countess \t;endclass",
-     "class i_love_data;\n"
-     "  int counter;\n"
-     "  int countess;\n"
-     "endclass\n"},
-    {"class  i_love_params ;foo#( . bar)  baz\t;endclass",
-     "class i_love_params;\n"
-     "  foo #(.bar) baz;\n"
-     "endclass\n"},
-    {"class  i_love_params ;foo#( . bar ( bah ))  baz\t;endclass",
-     "class i_love_params;\n"
-     "  foo #(.bar(bah)) baz;\n"
-     "endclass\n"},
-    {"class  i_love_params ;foo#( . bar ( bah\n),"
-     ".\ncat( dog) )  baz\t;endclass",
-     "class i_love_params;\n"
-     "  foo #(\n"
-     "      .bar(bah),\n"
-     "      .cat(dog)\n"
-     "  ) baz;\n"
-     "endclass\n"},
-    {"class  i_love_params ;foo#( . bar)  baz1,baz2\t;endclass",
-     "class i_love_params;\n"
-     "  foo #(.bar) baz1, baz2;\n"
-     "endclass\n"},
-    {"class  i_love_params ;foo#( . bar)  baz\t;baz#(.foo)bar;endclass",
-     "class i_love_params;\n"
-     "  foo #(.bar) baz;\n"
-     "  baz #(.foo) bar;\n"
-     "endclass\n"},
-    {"class i_love_params // comment\n"
-     ";\n"
-     "foo#(\n"
-     ".foobar(quuuuux) // comment\n"
-     ", .cat(dog)\n"
-     ") baz // comment\n"
-     ";endclass\n",
-     "class i_love_params  // comment\n"
-     ";\n"
-     "  foo #(\n"
-     "        .foobar(quuuuux)  // comment\n"
-     "      , .cat   (dog)\n"
-     "  ) baz  // comment\n"
-     "  ;\n"
-     "endclass\n"},
-
-    // typedef test cases
-    {"typedef enum logic\t{ A=0, B=1 }foo_t;",
-     "typedef enum logic {\n"
-     "  A = 0,\n"
-     "  B = 1\n"
-     "} foo_t;\n"},
-    {"typedef enum uint8_t\t{ kA=8'b0, kB=8'b1 }foo_t;",
-     "typedef enum uint8_t {\n"  // uint8_t is user-defined
-     "  kA = 8'b0,\n"
-     "  kB = 8'b1\n"
-     "} foo_t;\n"},
-    {// With comments on same line as enum value
-     "typedef enum logic\t{ A=0, // foo\n"
-     "B,// bar\n"
-     "`ifndef DO_PANIC\n"
-     "C=42,// answer\n"
-     "`endif\n"
-     "D=3    // baz\n"
-     "}foo_t;",
-     "typedef enum logic {\n"
-     "  A = 0,   // foo\n"
-     "  B,       // bar\n"
-     "`ifndef DO_PANIC\n"
-     "  C = 42,  // answer\n"
-     "`endif\n"
-     "  D = 3    // baz\n"
-     "} foo_t;\n"},
-    {// with scalar dimensions
-     "typedef enum logic[2]\t{ A=0, B=1 }foo_t;",
-     "typedef enum logic [2] {\n"
-     "  A = 0,\n"
-     "  B = 1\n"
-     "} foo_t;\n"},
-    {// with range dimensions
-     "typedef enum logic[1:0]\t{ A=0, B=1 }foo_t;",
-     "typedef enum logic [1:0] {\n"
-     "  A = 0,\n"
-     "  B = 1\n"
-     "} foo_t;\n"},
-    {"typedef foo_pkg::baz_t#(.L(L), .W(W)) bar_t;\n",
-     "typedef foo_pkg::baz_t#(\n"
-     "    .L(L),\n"
-     "    .W(W)\n"
-     ") bar_t;\n"},
-    // unqualified parameterized type keeps a space before '#'
-    {"typedef dv_base_env_cov #(.CFG_T(tl_agent_env_cfg)) tl_agent_env_cov;\n",
-     "typedef dv_base_env_cov #(\n"
-     "    .CFG_T(tl_agent_env_cfg)\n"
-     ") tl_agent_env_cov;\n"},
-    // ... and is inserted when absent
-    {"typedef dv_base_env_cov#(.CFG_T(tl_agent_env_cfg)) tl_agent_env_cov;\n",
-     "typedef dv_base_env_cov #(\n"
-     "    .CFG_T(tl_agent_env_cfg)\n"
-     ") tl_agent_env_cov;\n"},
-    // single short parameter stays on one line
-    {"typedef my_class #(.P(P)) my_class_t;\n",
-     "typedef my_class #(.P(P)) my_class_t;\n"},
-
-    // package test cases
-    {"package fedex;localparam  int  www=3 ;endpackage   :  fedex\n",
-     "package fedex;\n"
-     "  localparam int www = 3;\n"
-     "endpackage : fedex\n"},
-    {"package   typey ;"
-     "typedef enum int{ A=0, B=1 }foo_t;"
-     "typedef enum{ C=0, D=1 }bar_t;"
-     "endpackage:typey\n",
-     "package typey;\n"
-     "  typedef enum int {\n"
-     "    A = 0,\n"
-     "    B = 1\n"
-     "  } foo_t;\n"
-     "  typedef enum {\n"
-     "    C = 0,\n"
-     "    D = 1\n"
-     "  } bar_t;\n"
-     "endpackage : typey\n"},
-    {// net type declarations
-     "package foo_pkg;"
-     "nettype shortreal\t\tfoo  ;"
-     "nettype\nbar[1:0 ] baz  with\tquux ;"
-     "endpackage",
-     "package foo_pkg;\n"
-     "  nettype shortreal foo;\n"
-     "  nettype bar [1:0] baz with quux;\n"
-     "endpackage\n"},
-    {"package foo_pkg; \n"
-     "// function description.......\n"
-     "function automatic void bar();"
-     "endfunction "
-     "endpackage\n",
-     "package foo_pkg;\n"
-     "  // function description.......\n"
-     "  function automatic void bar();\n"
-     "  endfunction\n"
-     "endpackage\n"},
-    {"package foo_pkg; \n"
-     "// function description.......\n"
-     "function void bar(string name=\"x\" ) ;"
-     "endfunction "
-     "endpackage\n",
-     "package foo_pkg;\n"
-     "  // function description.......\n"
-     "  function void bar(string name = \"x\");\n"
-     "  endfunction\n"
-     "endpackage\n"},
-    {" package foo_pkg; \n"
-     "// class description.............\n"
-     "class classy;"
-     "endclass "
-     "endpackage\n",
-     "package foo_pkg;\n"
-     "  // class description.............\n"
-     "  class classy;\n"
-     "  endclass\n"
-     "endpackage\n"},
-    {"package\tfoo_pkg; \n"
-     "// class description.............\n"
-     "class   classy;    \n"
-     "// function description.......\n"
-     "function\nautomatic   void bar( );"
-     "endfunction   "
-     "endclass\t"
-     "endpackage\n",
-     "package foo_pkg;\n"
-     "  // class description.............\n"
-     "  class classy;\n"
-     "    // function description.......\n"
-     "    function automatic void bar();\n"
-     "    endfunction\n"
-     "  endclass\n"
-     "endpackage\n"},
-    {"package fedex;\n"
-     "  import \"asdf\" context function void bar(\n"
-     "    input bit              [2:1] aaaa,   // EOL COMMENT\n"
-     "                                          // another\n"
-     "    input bit foo\n"
-     "  );\n"
-     "endpackage\n",
-     "package fedex;\n"
-     "  import \"asdf\" context\n"
-     "      function void bar(\n"
-     "    input\n        bit [2:1] aaaa,  // EOL COMMENT\n"
-     "                         // another\n"
-     "    input bit foo\n"
-     "  );\n"
-     "endpackage\n"},
-
-    // function test cases
-    {"function f ;endfunction", "function f;\nendfunction\n"},
-    {"function f ;endfunction:   f", "function f;\nendfunction : f\n"},
-    {"function f ( );endfunction", "function f();\nendfunction\n"},
-    {"function f (input bit x);endfunction",
-     "function f(input bit x);\nendfunction\n"},
-    {"function f (input bit x,logic y );endfunction",
-     "function f(input bit x, logic y);\nendfunction\n"},
-    {"function f;\n// statement comment\nendfunction\n",
-     "function f;\n"
-     "  // statement comment\n"  // indented
-     "endfunction\n"},
-    {"function f();\n// statement comment\nendfunction\n",
-     "function f();\n"
-     "  // statement comment\n"  // indented
-     "endfunction\n"},
-    {"function f(input int x);\n"
-     "// statement comment\n"
-     "f=x;\n"
-     "// statement comment\n"
-     "endfunction\n",
-     "function f(input int x);\n"
-     "  // statement comment\n"  // indented
-     "  f = x;\n"
-     "  // statement comment\n"  // indented
-     "endfunction\n"},
-    {// line breaks around assignments
-     "function f;a=b;c+=d;endfunction",
-     "function f;\n"
-     "  a = b;\n"
-     "  c += d;\n"
-     "endfunction\n"},
-    {"function f;a&=b;c=d;endfunction",
-     "function f;\n"
-     "  a &= b;\n"
-     "  c = d;\n"
-     "endfunction\n"},
-    {"function f;a<<=b;c=b;d>>>=b;endfunction",
-     "function f;\n"
-     "  a <<= b;\n"
-     "  c = b;\n"
-     "  d >>>= b;\n"
-     "endfunction\n"},
-    {// port declaration exceeds line length limit
-     "function f (loooong_type if_it_fits_I_sits);endfunction",
-     "function f(\n"
-     "    loooong_type if_it_fits_I_sits);\n"
-     "endfunction\n"},
-    {"function\nvoid\tspace;a=( b+c )\n;endfunction   :space\n",
-     "function void space;\n"
-     "  a = (b + c);\n"
-     "endfunction : space\n"},
-    {"function\nvoid\twarranty;return  to_sender\n;endfunction   :warranty\n",
-     "function void warranty;\n"
-     "  return to_sender;\n"
-     "endfunction : warranty\n"},
-    {// if statement that fits on one line
-     "function if_i_fits_i_sits;"
-     "if(x)y=x;"
-     "endfunction",
-     "function if_i_fits_i_sits;\n"
-     "  if (x) y = x;\n"
-     "endfunction\n"},
-    {// for loop
-     "function\nvoid\twarranty;for(j=0; j<k; --k)begin "
-     "++j\n;end endfunction   :warranty\n",
-     "function void warranty;\n"
-     "  for (j = 0; j < k; --k) begin\n"
-     "    ++j;\n"
-     "  end\n"
-     "endfunction : warranty\n"},
-    {// for loop that needs wrapping
-     "function\nvoid\twarranty;for(jjjjj=0; jjjjj<kkkkk; --kkkkk)begin "
-     "++j\n;end endfunction   :warranty\n",
-     "function void warranty;\n"
-     "  for (\n"
-     "      jjjjj = 0; jjjjj < kkkkk; --kkkkk\n"
-     "  ) begin\n"
-     "    ++j;\n"
-     "  end\n"
-     "endfunction : warranty\n"},
-    {// for loop that needs more wrapping
-     "function\nvoid\twarranty;"
-     "for(jjjjjjjj=0; jjjjjjjj<kkkkkkkk; --kkkkkkkk)begin "
-     "++j\n;end endfunction   :warranty\n",
-     "function void warranty;\n"
-     "  for (\n"
-     "      jjjjjjjj = 0;\n"
-     "      jjjjjjjj < kkkkkkkk;\n"
-     "      --kkkkkkkk\n"
-     "  ) begin\n"
-     "    ++j;\n"
-     "  end\n"
-     "endfunction : warranty\n"},
-    {// for loop that fits on one line
-     "function loop_fits;"
-     "for(x=0;x<N;++x) y=x;"
-     "endfunction",
-     "function loop_fits;\n"
-     "  for (x = 0; x < N; ++x) y = x;\n"
-     "endfunction\n"},
-    {// for loop that would fit on one line, but is force-split with //comment
-     "function loop_fits;"
-     "for(x=0;x<N;++x) //\n y=x;"
-     "endfunction",
-     "function loop_fits;\n"
-     "  for (x = 0; x < N; ++x)  //\n"
-     "    y = x;\n"
-     "endfunction\n"},
-    {// for loop with function call in initializer
-     "function  void looper(); "
-     "for (int i=f(n); i>=0; i -- ) begin end "
-     "endfunction",
-     "function void looper();\n"
-     "  for (int i = f(n); i >= 0; i--) begin\n"
-     "  end\n"
-     "endfunction\n"},
-    {// for loop with function call in condition
-     "function  void looper(); "
-     "for (int i=0; i<f(m); i -- ) begin end "
-     "endfunction",
-     "function void looper();\n"
-     "  for (int i = 0; i < f(m); i--) begin\n"
-     "  end\n"
-     "endfunction\n"},
-    {// forever loop
-     "function\nvoid\tforevah;forever  begin "
-     "++k\n;end endfunction\n",
-     "function void forevah;\n"
-     "  forever begin\n"
-     "    ++k;\n"
-     "  end\n"
-     "endfunction\n"},
-    {// forever loop
-     "function\nvoid\tforevah;forever  "
-     "++k\n;endfunction\n",
-     "function void forevah;\n"
-     "  forever ++k;\n"
-     "endfunction\n"},
-    {// forever loop, forced break
-     "function\nvoid\tforevah;forever     //\n"
-     "++k\n;endfunction\n",
-     "function void forevah;\n"
-     "  forever  //\n"
-     "    ++k;\n"
-     "endfunction\n"},
-    {// repeat loop
-     "function\nvoid\tpete;repeat(3)  begin "
-     "++k\n;end endfunction\n",
-     "function void pete;\n"
-     "  repeat (3) begin\n"
-     "    ++k;\n"
-     "  end\n"
-     "endfunction\n"},
-    {// repeat loop
-     "function\nvoid\tpete;repeat(3)  "
-     "++k\n;endfunction\n",
-     "function void pete;\n"
-     "  repeat (3)++k;\n"  // TODO(fangism): space before ++
-     "endfunction\n"},
-    {// repeat loop, forced break
-     "function\nvoid\tpete;repeat(3)//\n"
-     "++k\n;endfunction\n",
-     "function void pete;\n"
-     "  repeat (3)  //\n"
-     "    ++k;\n"
-     "endfunction\n"},
-    {// while loop
-     "function\nvoid\twily;while( coyote )  begin "
-     "++super_genius\n;end endfunction\n",
-     "function void wily;\n"
-     "  while (coyote) begin\n"
-     "    ++super_genius;\n"
-     "  end\n"
-     "endfunction\n"},
-    {// while loop
-     "function\nvoid\twily;while( coyote )  "
-     "++ super_genius\n;   endfunction\n",
-     "function void wily;\n"
-     "  while (coyote)++super_genius;\n"  // TODO(fangism): space before ++
-     "endfunction\n"},
-    {// while loop, forced break
-     "function\nvoid\twily;while( coyote ) //\n "
-     "++ super_genius\n;   endfunction\n",
-     "function void wily;\n"
-     "  while (coyote)  //\n"
-     "    ++super_genius;\n"
-     "endfunction\n"},
-    {// do-while loop
-     "function\nvoid\tdonot;do  begin "
-     "++s\n;end  while( z);endfunction\n",
-     "function void donot;\n"
-     "  do begin\n"
-     "    ++s;\n"
-     "  end while (z);\n"
-     "endfunction\n"},
-    {// do-while loop, single statement
-     "function\nvoid\tdonot;do  "
-     "++s\n;  while( z);endfunction\n",
-     "function void donot;\n"
-     "  do ++s; while (z);\n"
-     "endfunction\n"},
-    {// do-while loop, single statement, forced break
-     "function\nvoid\tdonot;do  "
-     "++s\n;//\n  while( z);endfunction\n",
-     "function void donot;\n"
-     "  do\n"
-     "    ++s;  //\n"
-     "  while (z);\n"
-     "endfunction\n"},
-    {// foreach loop
-     "function\nvoid\tforeacher;foreach( m [n] )  begin "
-     "++m\n;end endfunction\n",
-     "function void foreacher;\n"
-     "  foreach (m[n]) begin\n"
-     "    ++m;\n"
-     "  end\n"
-     "endfunction\n"},
-    {// spaces in condition expression
-     "function f; return {a}? {b} :{ c };endfunction",
-     "function f;\n"
-     "  return {a} ? {b} : {c};\n"
-     "endfunction\n"},
-    {"task t;endtask",
-     "task t;\n"
-     "endtask\n"},
-    {"task t (   );endtask",
-     "task t();\n"
-     "endtask\n"},
-    {"task t (input    bit   drill   ) ;endtask",
-     "task t(input bit drill);\n"
-     "endtask\n"},
-    {"task t; ## 100 ;endtask",
-     "task t;\n"
-     "  ##100;\n"
-     "endtask\n"},
-    {"task t; ## (1+1) ;endtask",  // delay expression
-     "task t;\n"
-     "  ##(1 + 1);\n"
-     "endtask\n"},
-    {"task t; ## delay_value ;endtask",
-     "task t;\n"
-     "  ##delay_value;\n"
-     "endtask\n"},
-    {"task t; ## `DELAY_VALUE ;endtask",
-     "task t;\n"
-     "  ##`DELAY_VALUE;\n"
-     "endtask\n"},
-    {"task t;\n"
-     "`uvm_error( foo,bar);\n"
-     "endtask\n",
-     "task t;\n"
-     "  `uvm_error(foo, bar);\n"
-     "endtask\n"},
-    {"task t;\n"
-     "`uvm_error(foo,bar)\n"
-     ";\n"  // null statement
-     "endtask\n",
-     "task t;\n"
-     "  `uvm_error(foo, bar)\n"
-     "  ;\n"
-     "endtask\n"},
-    {"task t;\n"
-     "if(expr)begin\t\n"
-     "`uvm_error(foo,bar);\n"
-     "end\n"
-     "endtask\n",
-     "task t;\n"
-     "  if (expr) begin\n"
-     "    `uvm_error(foo, bar);\n"
-     "  end\n"
-     "endtask\n"},
-    {"task\nrabbit;$kill(the,\nrabbit)\n;endtask:  rabbit\n",
-     "task rabbit;\n"
-     "  $kill(the, rabbit);\n"
-     "endtask : rabbit\n"},
-    {"function  int foo( );if( a )a+=1 ; endfunction",
-     "function int foo();\n"
-     "  if (a) a += 1;\n"
-     "endfunction\n"},
-    {"function  void foo( );foo=`MACRO(b,c) ; endfunction",
-     "function void foo();\n"
-     "  foo = `MACRO(b, c);\n"
-     "endfunction\n"},
-    {"module foo;if    \t  (bar)begin assign a=1; end endmodule",
-     "module foo;\n"
-     "  if (bar) begin\n"
-     "    assign a = 1;\n"
-     "  end\n"
-     "endmodule\n"},
-    {"module proc_cont_assigner;\n"
-     "always begin\n"
-     "assign x1 =   y1;\n"
-     "deassign   x2 ;\n"
-     "force x3=y3;\n"
-     "release   x4 ;\n"
-     "end\n"
-     "endmodule\n",
-     "module proc_cont_assigner;\n"
-     "  always begin\n"
-     "    assign x1 = y1;\n"
-     "    deassign x2;\n"
-     "    force x3 = y3;\n"
-     "    release x4;\n"
-     "  end\n"
-     "endmodule\n"},
-    {"module g_test(  );\n"
-     "\tinitial begin:main_test \t"
-     "for(int i=0;i<k;i++)begin "
-     "case(i )\n"
-     " 6'd0  :release in[0];  \n"
-     "   endcase  "
-     " \t\tend \t"
-     "\t end:main_test\n"
-     "endmodule:g_test\n",
-     "module g_test ();\n"
-     "  initial begin : main_test\n"
-     "    for (int i = 0; i < k; i++) begin\n"
-     "      case (i)\n"
-     "        6'd0: release in[0];\n"
-     "      endcase\n"
-     "    end\n"
-     "  end : main_test\n"
-     "endmodule : g_test\n"},
-    {// conditional generate (case)
-     "module mc; case(s)a : bb c ; d : ee f; endcase endmodule",
-     "module mc;\n"
-     "  case (s)\n"
-     "    a: bb c;\n"
-     "    d: ee f;\n"
-     "  endcase\n"
-     "endmodule\n"},
-    {// conditional generate (case), with comments
-     "module mc; case(s)\n//comment a\na:bb  c;\n//comment b\n endcase "
-     "endmodule",
-     "module mc;\n"
-     "  case (s)\n"
-     "    //comment a\n"  // indented to case-item level
-     "    a: bb c;\n"
-     "    //comment b\n"  // indented to case-item level
-     "  endcase\n"
-     "endmodule\n"},
-
-    {// "default:", not "default :"
-     "function f; case (x) default: x=y; endcase endfunction\n",
-     "function f;\n"
-     "  case (x)\n"
-     "    default: x = y;\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// default with null statement: "default: ;", not "default :;"
-     "function f; case (x) default :; endcase endfunction\n",
-     "function f;\n"
-     "  case (x)\n"
-     "    default: ;\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// case statement
-     "function f; case (x) State0 : a=b; State1 : begin a=b; end "
-     "endcase endfunction\n",
-     "function f;\n"
-     "  case (x)\n"
-     "    State0: a = b;\n"
-     "    State1: begin\n"
-     "      a = b;\n"
-     "    end\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// case statement, interleaved with comments
-     "function f; case (x) \n//c1\nState0 : a=b;//c2\n//c3\n State1 : "
-     "a=b;//c4\n//c5\n "
-     "endcase endfunction\n",
-     "function f;\n"
-     "  case (x)\n"
-     "    //c1\n"
-     "    State0: a = b;  //c2\n"
-     "    //c3\n"
-     "    State1: a = b;  //c4\n"
-     "    //c5\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// case inside statement, comments
-     "function f; case (x)inside \n//comment\n"
-     "[0:1]:x=y; \n"
-     "    //comment\n"
-     "endcase endfunction\n",
-     "function f;\n"
-     "  case (x) inside\n"
-     "    //comment\n"
-     "    [0 : 1]: x = y;\n"
-     "    //comment\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// case inside statement
-     "function f; case (x)inside k1 : return b; k2 : begin return b; end "
-     "endcase endfunction\n",
-     "function f;\n"
-     "  case (x) inside\n"
-     "    k1: return b;\n"
-     "    k2: begin\n"
-     "      return b;\n"
-     "    end\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// case inside statement, with ranges
-     "function f; case (x) inside[a:b] : return b; [c:d] : return b; "
-     "default :return z;"
-     "endcase endfunction\n",
-     "function f;\n"
-     "  case (x) inside\n"
-     "    [a : b]: return b;\n"
-     "    [c : d]: return b;\n"
-     "    default: return z;\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// case pattern statement
-     "function f;"
-     "case (y) matches "
-     ".foo   : return 0;"
-     ".*\t: return 1;"
-     "endcase "
-     "case (z) matches "
-     ".foo\t\t: return 0;"
-     ".*   : return 1;"
-     "endcase "
-     "endfunction",
-     "function f;\n"
-     "  case (y) matches\n"
-     "    .foo: return 0;\n"
-     "    .*: return 1;\n"
-     "  endcase\n"
-     "  case (z) matches\n"
-     "    .foo: return 0;\n"
-     "    .*: return 1;\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// keep short case items on one line
-     "function f; case (x)k1 : if( b )break; default :return 2;"
-     "endcase endfunction\n",
-     "function f;\n"
-     "  case (x)\n"
-     "    k1:      if (b) break;\n"  // aligned
-     "    default: return 2;\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// keep short default items on one line
-     "function f; case (x)k1 :break; default :if( c )return 2;"
-     "endcase endfunction\n",
-     "function f;\n"
-     "  case (x)\n"
-     "    k1:      break;\n"  // aligned
-     "    default: if (c) return 2;\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// keep short case inside items on one line
-     "function f; case (x)inside k1 : if( b )return c; k2 : return a;"
-     "endcase endfunction\n",
-     "function f;\n"
-     "  case (x) inside\n"
-     "    k1: if (b) return c;\n"
-     "    k2: return a;\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// keep short case pattern items on one line
-     "function f;"
-     "case (y) matches "
-     ".foo   :if( n )return 0;"
-     ".*\t: return 1;"
-     "endcase "
-     "endfunction",
-     "function f;\n"
-     "  case (y) matches\n"
-     "    .foo: if (n) return 0;\n"
-     "    .*: return 1;\n"
-     "  endcase\n"
-     "endfunction\n"},
-    {// randcase
-     "function f; randcase k1 : return c; k2 : return a;"
-     "endcase endfunction\n",
-     "function f;\n"
-     "  randcase\n"
-     "    k1: return c;\n"
-     "    k2: return a;\n"
-     "  endcase\n"
-     "endfunction\n"},
-
-    // This tests checks for not breaking around hierarchy operators.
-    {"function\nvoid\twarranty;"
-     "foo.bar = fancyfunction(aaaaaaaa.bbbbbbb,"
-     "    ccccccccc.ddddddddd) ;"
-     "endfunction   :warranty\n",
-     "function void warranty;\n"
-     "  foo.bar = fancyfunction(\n"
-     "      aaaaaaaa.bbbbbbb,\n"
-     "      ccccccccc.ddddddddd\n"
-     "  );\n"
-     "endfunction : warranty\n"},
-
-    // Group of tests testing partitioning of arguments inside function calls
-    {// function with function call inside if statement header
-     "function foo;if(aa(bb,cc));endfunction\n",
-     "function foo;\n"
-     "  if (aa(bb, cc));\n"
-     "endfunction\n"},
-    {// function with function call inside if statement header and with
-     // begin-end block
-     "function foo;if (aa(bb,cc,dd,ee))begin end endfunction\n",
-     "function foo;\n"
-     "  if (aa(bb, cc, dd, ee)) begin\n"
-     "  end\n"
-     "endfunction\n"},
-    {// function with kMethodCallExtension inside if statement header and with
-     // begin-end block
-     "function foo;if (aa.bb(cc,dd,ee))begin end endfunction\n",
-     "function foo;\n"
-     "  if (aa.bb(cc, dd, ee)) begin\n"
-     "  end\n"
-     "endfunction\n"},
-    {// nested kMethodCallExtension calls - one level
-     "function foo;aa.bb(cc.dd(a1), ee.ff(a2));endfunction\n",
-     "function foo;\n"
-     "  aa.bb(cc.dd(a1), ee.ff(a2));\n"
-     "endfunction\n"},
-    {// nested kMethodCallExtension calls - two level
-     "function foo;aa.bb(cc.dd(a1.b1(a2), b1), ee.ff(c1, d1));endfunction\n",
-     "function foo;\n"
-     "  aa.bb(cc.dd(a1.b1(a2), b1), ee.ff(\n"
-     "        c1, d1));\n"
-     "endfunction\n"},
-
-    {// simple initial statement with function call
-     "module m;initial aa(bb,cc,dd,ee);endmodule\n",
-     "module m;\n"
-     "  initial aa(bb, cc, dd, ee);\n"
-     "endmodule\n"},
-    {// expressions and function calls inside if-statement headers
-     "module m;initial begin if(aa(bb)==cc(dd))a=b;if (xx()) b = a;end "
-     "endmodule\n",
-     "module m;\n"
-     "  initial begin\n"
-     "    if (aa(bb) == cc(dd)) a = b;\n"
-     "    if (xx()) b = a;\n"
-     "  end\n"
-     "endmodule\n"},
-    {// fuction with two arguments inside if-statement headers
-     "module\nm;initial\nbegin\nif(aa(bb,cc))x=y;end\nendmodule\n",
-     "module m;\n"
-     "  initial begin\n"
-     "    if (aa(bb, cc)) x = y;\n"
-     "  end\n"
-     "endmodule\n"},
-    {// kMethodCallExtension inside if-statement headers
-     "module m;initial begin if (aa.bb(cc)) x = y;end endmodule",
-     "module m;\n"
-     "  initial begin\n"
-     "    if (aa.bb(cc)) x = y;\n"
-     "  end\n"
-     "endmodule\n"},
-    {// initial statement with object method call
-     "module m; initial a.b(a,b,c); endmodule\n",
-     "module m;\n"
-     "  initial a.b(a, b, c);\n"
-     "endmodule\n"},
-    {// initial statement with method call on indexed object
-     "module m; initial a[i].b(a,b,c); endmodule\n",
-     "module m;\n"
-     "  initial a[i].b(a, b, c);\n"
-     "endmodule\n"},
-    {// initial statement with method call on function returned object
-     "module m; initial a(d,e,f).b(a,b,c); endmodule\n",
-     "module m;\n"
-     "  initial a(d, e, f).b(a, b, c);\n"
-     "endmodule\n"},
-    {// initial statement with indexed access to function returned object
-     "module m; initial a(a,b,c)[i]; endmodule\n",
-     "module m;\n"
-     "  initial a(a, b, c) [i];\n"
-     "endmodule\n"},
-    {// method call with no arguments on an object
-     "module m; initial foo.bar();endmodule\n",
-     "module m;\n"
-     "  initial foo.bar();\n"
-     "endmodule\n"},
-    {// method call with one argument on an object
-     "module m; initial foo.bar(aa);endmodule\n",
-     "module m;\n"
-     "  initial foo.bar(aa);\n"
-     "endmodule\n"},
-    {// method call with two arguments on an object
-     "module m; initial foo.bar(aa,bb);endmodule\n",
-     "module m;\n"
-     "  initial foo.bar(aa, bb);\n"
-     "endmodule\n"},
-    {// method call with three arguments on an object
-     "module m; initial foo.bar(aa,bb,cc);endmodule\n",
-     "module m;\n"
-     "  initial foo.bar(aa, bb, cc);\n"
-     "endmodule\n"},
-
-    {
-        // This tests for if-statements with null statements
-        "function foo;"
-        "if (zz) ; "
-        "if (yy) ; "
-        "endfunction",
-        "function foo;\n"
-        "  if (zz);\n"
-        "  if (yy);\n"
-        "endfunction\n",
-    },
-
-    {
-        // This tests for if-statements starting on their own line.
-        "function foo;"
-        "if (zz) begin "
-        "return 0;"
-        "end "
-        "if (yy) begin "
-        "return 1;"
-        "end "
-        "endfunction",
-        "function foo;\n"
-        "  if (zz) begin\n"
-        "    return 0;\n"
-        "  end\n"
-        "  if (yy) begin\n"
-        "    return 1;\n"
-        "  end\n"
-        "endfunction\n",
-    },
-
-    {
-        // This tests for if-statements with single statement bodies
-        "function foo;"
-        "if (zz) return 0;"
-        "if (yy) return 1;"
-        "endfunction",
-        "function foo;\n"
-        "  if (zz) return 0;\n"
-        "  if (yy) return 1;\n"
-        "endfunction\n",
-    },
-
-    {
-        // This tests for if-statement mixed with plain statements
-        "function foo;"
-        "a=b;"
-        "if (zz) return 0;"
-        "c=d;"
-        "endfunction",
-        "function foo;\n"
-        "  a = b;\n"
-        "  if (zz) return 0;\n"
-        "  c = d;\n"
-        "endfunction\n",
-    },
-
-    {
-        // This tests for if-statement with forced break mixed with others
-        "function foo;"
-        "a=b;"
-        "if (zz)//\n return 0;"
-        "c=d;"
-        "endfunction",
-        "function foo;\n"
-        "  a = b;\n"
-        "  if (zz)  //\n"
-        "    return 0;\n"
-        "  c = d;\n"
-        "endfunction\n",
-    },
-    {
-        "function t;"
-        "if (r == t)"
-        "a.b(c);"
-        "endfunction",
-        "function t;\n"
-        "  if (r == t) a.b(c);\n"
-        "endfunction\n",
-    },
-
-    {// This tests for for-statement with forced break mixed with others
-     "function f;"
-     "x=y;"
-     "for (int i=0; i<S*IPS; i++) #1ps a += $urandom();"
-     "return 2;"
-     "endfunction",
-     "function f;\n"
-     "  x = y;\n"
-     "  for (int i = 0; i < S * IPS; i++)\n"  // doesn't fit, so indents
-     "    #1ps a += $urandom();\n"
-     "  return 2;\n"
-     "endfunction\n"},
-
-    {
-        // This tests for-statements with null statements
-        "function foo;"
-        "for(;;)  ;\t"
-        "for(;;)  ;\t"
-        "endfunction",
-        "function foo;\n"
-        "  for (;;);\n"
-        "  for (;;);\n"
-        "endfunction\n",
-    },
-
-    {
-        // This tests for if-else-statements with null statements
-        "function foo;"
-        "if (zz) ;  else  ;"
-        "if (yy) ;   else   ;"
-        "endfunction",
-        "function foo;\n"
-        "  if (zz);\n"
-        "  else;\n"
-        "  if (yy);\n"
-        "  else;\n"
-        "endfunction\n",
-    },
-
-    {
-        // This tests for end-else-begin.
-        "function foo;"
-        "if (zz) begin "
-        "return 0;"
-        "end "
-        "else "
-        "begin "
-        "return 1;"
-        "end "
-        "endfunction",
-        "function foo;\n"
-        "  if (zz) begin\n"
-        "    return 0;\n"
-        "  end else begin\n"
-        "    return 1;\n"
-        "  end\n"
-        "endfunction\n",
-    },
-    {
-        // This tests for end-else-if
-        "function foo;"
-        "if (zz) begin "
-        "return 0;"
-        "end "
-        "else "
-        "if(yy)begin "
-        "return 1;"
-        "end "
-        "endfunction",
-        "function foo;\n"
-        "  if (zz) begin\n"
-        "    return 0;\n"
-        "  end else if (yy) begin\n"
-        "    return 1;\n"
-        "  end\n"
-        "endfunction\n",
-    },
-    {
-        // This tests labeled end-else-if
-        "function foo;"
-        "if (zz) begin : label1 "
-        "return 0;"
-        "end : label1 "
-        "else if (yy) begin : label2 "
-        "return 1;"
-        "end : label2 "
-        "endfunction",
-        "function foo;\n"
-        "  if (zz) begin : label1\n"
-        "    return 0;\n"
-        "  end : label1\n"
-        "  else if (yy) begin : label2\n"
-        "    return 1;\n"
-        "  end : label2\n"
-        "endfunction\n",
-    },
-    {
-        // This tests labeled end-else-if-else
-        "function foo;"
-        "if (zz) begin : label1 "
-        "return 0;"
-        "end : label1 "
-        "else if (yy) begin : label2 "
-        "return 1;"
-        "end : label2 "
-        "else begin : label3 "
-        "return 2;"
-        "end : label3 "
-        "endfunction",
-        "function foo;\n"
-        "  if (zz) begin : label1\n"
-        "    return 0;\n"
-        "  end : label1\n"
-        "  else if (yy) begin : label2\n"
-        "    return 1;\n"
-        "  end : label2\n"
-        "  else begin : label3\n"
-        "    return 2;\n"
-        "  end : label3\n"
-        "endfunction\n",
-    },
-
-    {
-        // randomize function
-        "function r ;"
-        "if ( ! randomize (bar )) begin    end "
-        "if ( ! obj.randomize (bar )) begin    end "
-        "endfunction",
-        "function r;\n"
-        "  if (!randomize(bar)) begin\n"
-        "  end\n"
-        "  if (!obj.randomize(bar)) begin\n"
-        "  end\n"
-        "endfunction\n",
-    },
-    {
-        // randomize-with call, with comments
-        "function f;"
-        "s = std::randomize() with {\n"
-        "// comment1\n"
-        "a == e;\n"
-        "// comment2\n"
-        "};"
-        "endfunction\n",
-        "function f;\n"
-        "  s = std::randomize() with {\n"
-        "    // comment1\n"
-        "    a == e;\n"
-        "    // comment2\n"
-        "  };\n"
-        "endfunction\n",
-    },
-    {
-        // randomize-with call, with comments, one joined
-        "function f;"
-        "s = std::randomize() with {\n"
-        "// comment1\n"
-        "a == e;// comment2\n"
-        "};"
-        "endfunction\n",
-        "function f;\n"
-        "  s = std::randomize() with {\n"
-        "    // comment1\n"
-        "    a == e;  // comment2\n"
-        "  };\n"
-        "endfunction\n",
-    },
-    {
-        // randomize-with call, with comment, and conditional
-        "function f;"
-        "s = std::randomize() with {\n"
-        "// comment\n"
-        "a == e;"
-        "if (x) {"
-        "a;"
-        "}"
-        "};"
-        "endfunction\n",
-        "function f;\n"
-        "  s = std::randomize() with {\n"
-        "    // comment\n"
-        "    a == e;\n"
-        "    if (x) {a;}\n"  // TODO(fangism): consider expanding
-        "  };\n"
-        "endfunction\n",
-    },
-
-    // module declaration test cases
-    {"   module       foo  ;     endmodule\n",
-     "module foo;\n"
-     "endmodule\n"},
-    {"   module       foo   (    )   ;     endmodule\n",
-     "module foo ();\n"
-     "endmodule\n"},
-    {"   module       foo   (  .x (  x) );     endmodule\n",
-     "module foo (\n"
-     "    .x(x)\n"
-     ");\n"
-     "endmodule\n"},
-    {"   module       foo   (  .x (  x)  \n,\n . y "
-     "  ( \ny) );     endmodule\n",
-     "module foo (\n"
-     "    .x(x),\n"
-     "    .y(y)\n"
-     ");\n"
-     "endmodule\n"},
-
-    // module instantiation test cases
-    {"  module foo   ; bar bq();endmodule\n",
-     "module foo;\n"
-     "  bar bq ();\n"  // single instance
-     "endmodule\n"},
-    {"  module foo   ; bar bq(), bq2(  );endmodule\n",
-     "module foo;\n"
-     "  bar bq (), bq2 ();\n"  // multiple instances, still fitting on one line
-     "endmodule\n"},
-    {"module foo; bar #(.N(N)) bq (.bus(bus));endmodule\n",
-     // instance parameter and port fits on line
-     "module foo;\n"
-     "  bar #(.N(N)) bq (.bus(bus));\n"
-     "endmodule\n"},
-    {"module foo; bar #(.N(N),.M(M)) bq ();endmodule\n",  // two named params
-     "module foo;\n"
-     "  bar #(\n"
-     "      .N(N),\n"
-     "      .M(M)\n"
-     "  ) bq ();\n"
-     "endmodule\n"},
-    {"module foo; bar #(//comment\n.N(N),.M(M)) bq ();endmodule\n",
-     "module foo;\n"
-     "  bar #(  //comment\n"  // EOL comment before first param
-     "      .N(N),\n"
-     "      .M(M)\n"
-     "  ) bq ();\n"
-     "endmodule\n"},
-    {"module foo; bar #(.N(N),//comment\n.M(M)) bq ();endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "      .N(N),  //comment\n"  // EOL comment after first param
-     "      .M(M)\n"
-     "  ) bq ();\n"
-     "endmodule\n"},
-    {"module foo; bar #(.N(N),.M(M)//comment\n) bq ();endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "      .N(N),\n"
-     "      .M(M)   //comment\n"  // EOL comment after last param
-     "  ) bq ();\n"
-     "endmodule\n"},
-    {"  module foo   ; bar bq(aa,bb,cc);endmodule\n",
-     "module foo;\n"
-     "  bar bq (\n"
-     "      aa,\n"
-     "      bb,\n"
-     "      cc\n"
-     "  );\n"  // multiple positional ports, one per line
-     "endmodule\n"},
-    {"  module foo   ; bar bq(aa,\n"
-     "`ifdef BB\n"
-     "bb,\n"
-     "`endif\n"
-     "cc);endmodule\n",
-     "module foo;\n"
-     "  bar bq (\n"
-     "      aa,\n"
-     "`ifdef BB\n"
-     "      bb,\n"  // keep same indentation as outside conditional
-     "`endif\n"
-     "      cc\n"
-     "  );\n"  // multiple positional ports, one per line
-     "endmodule\n"},
-    {"  module foo   ; bar bq(.aa,.bb);endmodule\n",
-     "module foo;\n"
-     "  bar bq (\n"
-     "      .aa,\n"
-     "      .bb\n"
-     "  );\n"  // multiple named ports, one per line
-     "endmodule\n"},
-    {"  module foo   ; bar bq(.aa(aa),.bb(bb));endmodule\n",
-     "module foo;\n"
-     "  bar bq (\n"
-     "      .aa(aa),\n"
-     "      .bb(bb)\n"
-     "  );\n"  // multiple named ports, one per line
-     "endmodule\n"},
-    {"  module foo   ; bar bq(.aa(aa),\n"
-     "`ifdef ZZ\n"
-     ".zz(  zz  ),\n"
-     "`else\n"
-     ".yy(  yy  ),\n"
-     "`endif\n"
-     ".bb(bb)\n"
-     ");endmodule\n",
-     "module foo;\n"
-     "  bar bq (\n"
-     "      .aa(aa),\n"
-     "`ifdef ZZ\n"
-     "      .zz(zz),\n"
-     "`else\n"
-     "      .yy(yy),\n"
-     "`endif\n"
-     "      .bb(bb)\n"
-     "  );\n"  // multiple named ports, one per line
-     "endmodule\n"},
-    {"  module foo   ; bar#(NNNNNNNN)"
-     "bq(.aa(aaaaaa),.bb(bbbbbb));endmodule\n",
-     "module foo;\n"
-     "  bar #(NNNNNNNN) bq (\n"
-     "      .aa(aaaaaa),\n"
-     "      .bb(bbbbbb)\n"
-     "  );\n"
-     "endmodule\n"},
-    {" module foo   ; barrrrrrr "
-     "bq(.aaaaaa(aaaaaa),.bbbbbb(bbbbbb));endmodule\n",
-     "module foo;\n"
-     "  barrrrrrr bq (\n"
-     "      .aaaaaa(aaaaaa),\n"
-     "      .bbbbbb(bbbbbb)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo; bar #(.NNNNN(NNNNN)) bq (.bussss(bussss));endmodule\n",
-     // instance parameter and port does not fit on line
-     "module foo;\n"
-     "  bar #(\n"
-     "      .NNNNN(NNNNN)\n"
-     "  ) bq (\n"
-     "      .bussss(bussss)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo; bar #(//\n.N(N)) bq (.bus(bus));endmodule\n",
-     "module foo;\n"
-     "  bar #(  //\n"  // would fit on one line, but forced to expand by //
-     "      .N(N)\n"
-     "  ) bq (\n"
-     "      .bus(bus)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo; bar #(\n"
-     "`ifdef MM\n"
-     ".M(M)\n"
-     "`else\n"
-     ".N(N)\n"
-     "`endif\n"
-     ") bq (.bus(bus));endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "`ifdef MM\n"
-     "      .M(M)\n"
-     "`else\n"
-     "      .N(N)\n"
-     "`endif\n"
-     "  ) bq (\n"
-     "      .bus(bus)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo; bar #(.N(N)//\n) bq (.bus(bus));endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"  // would fit on one line, but forced to expand by //
-     "      .N(N)  //\n"
-     "  ) bq (\n"
-     "      .bus(bus)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo; bar #(.N(N)) bq (//\n.bus(bus));endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"  // would fit on one line, but forced to expand by //
-     "      .N(N)\n"
-     "  ) bq (  //\n"
-     "      .bus(bus)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo; bar #(.N(N)) bq (.bus(bus)//\n);endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"  // would fit on one line, but forced to expand by //
-     "      .N(N)\n"
-     "  ) bq (\n"
-     "      .bus(bus)  //\n"
-     "  );\n"
-     "endmodule\n"},
-    {" module foo   ; bar "
-     "bq(.aaa(aaa),.bbb(bbb),.ccc(ccc),.ddd(ddd));endmodule\n",
-     "module foo;\n"
-     "  bar bq (\n"
-     "      .aaa(aaa),\n"  // ports don't fit on one line, so expanded
-     "      .bbb(bbb),\n"
-     "      .ccc(ccc),\n"
-     "      .ddd(ddd)\n"
-     "  );\n"
-     "endmodule\n"},
-    {" module foo   ; bar "
-     "bq(.aa(aa),.bb(bb),.cc(cc),.dd(dd));endmodule\n",
-     "module foo;\n"
-     "  bar bq (\n"
-     "      .aa(aa),\n"  // one named port per line
-     "      .bb(bb),\n"
-     "      .cc(cc),\n"
-     "      .dd(dd)\n"
-     "  );\n"
-     "endmodule\n"},
-    {" module foo   ; bar "
-     "bq(.aa(aa),//\n.bb(bb),.cc(cc),.dd(dd));endmodule\n",
-     "module foo;\n"
-     "  bar bq (\n"
-     "      .aa(aa),  //\n"  // forced to expand by //
-     "      .bb(bb),\n"
-     "      .cc(cc),\n"
-     "      .dd(dd)\n"
-     "  );\n"
-     "endmodule\n"},
-    {" module foo   ; bar "
-     "bq(.aa(aa),.bb(bb),.cc(cc),.dd(dd)//\n);endmodule\n",
-     "module foo;\n"
-     "  bar bq (\n"
-     "      .aa(aa),\n"
-     "      .bb(bb),\n"
-     "      .cc(cc),\n"
-     "      .dd(dd)   //\n"  // forced to expand by //
-     "  );\n"
-     "endmodule\n"},
-    {// gate instantiation test
-     "module m;"
-     "and\tx0(a, \t\tb,c);"
-     "or\nx1(a,  \n b,    d);"
-     "endmodule\n",
-     "module m;\n"
-     "  and x0 (a, b, c);\n"
-     "  or x1 (a, b, d);\n"
-     "endmodule\n"},
-    {// ifdef inside port actuals
-     "module m;  foo bar   (\n"
-     "`ifdef   BAZ\n"
-     "`endif\n"
-     ")  ;endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "`ifdef BAZ\n"
-     "`endif\n"
-     "  );\n"
-     "endmodule\n"},
-    {// ifdef inside port actuals after a port connection
-     "module m;  foo bar   ( .a (a) ,\n"
-     "`ifdef   BAZ\n"
-     "`endif\n"
-     ")  ;endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a(a),\n"
-     "`ifdef BAZ\n"
-     "`endif\n"
-     "  );\n"
-     "endmodule\n"},
-    {// ifdef inside port actuals before a port connection
-     "module m;  foo bar   (\n"
-     "`ifdef   BAZ\n"
-     "`endif\n"
-     ". b(b) )  ;endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "`ifdef BAZ\n"
-     "`endif\n"
-     "      .b(b)\n"
-     "  );\n"
-     "endmodule\n"},
-    {// ifdef-conditional port connection
-     "module m;  foo bar   (\n"
-     "`ifdef   BAZ\n"
-     ". c (\tc) \n"
-     "`endif\n"
-     " )  ;endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "`ifdef BAZ\n"
-     "      .c(c)\n"
-     "`endif\n"
-     "  );\n"
-     "endmodule\n"},
-    {// ifndef-else-conditional port connection
-     "module m;  foo bar   (\n"
-     "`ifndef   BAZ\n"
-     ". c (\tc) \n"
-     "  `else\n"
-     " . d(d\t)\n"
-     "  `endif\n"
-     " )  ;endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "`ifndef BAZ\n"
-     "      .c(c)\n"
-     "`else\n"
-     "      .d(d)\n"
-     "`endif\n"
-     "  );\n"
-     "endmodule\n"},
-
-    {// comment following a delay in next line
-     "module t;\n"
-     "reg x;\n"
-     "initial begin\n"
-     "#20\n"
-     "//comment\n"
-     "x = 1;\n"
-     "x = 2;\n"
-     "end\n"
-     "endmodule\n",
-     "module t;\n"
-     "  reg x;\n"
-     "  initial begin\n"
-     "    #20\n"
-     "    //comment\n"
-     "    x = 1;\n"
-     "    x = 2;\n"
-     "  end\n"
-     "endmodule\n"},
-    {// comment following a delay in the same line
-     "module t;\n"
-     "reg x;\n"
-     "initial begin\n"
-     "#20 //comment\n"
-     "x = 1;\n"
-     "x = 2;\n"
-     "end\n"
-     "endmodule\n",
-     "module t;\n"
-     "  reg x;\n"
-     "  initial begin\n"
-     "    #20  //comment\n"
-     "    x = 1;\n"
-     "    x = 2;\n"
-     "  end\n"
-     "endmodule\n"},
-    // Macro calls inside [...]
-    {"module foo;\nlogic [`BAR(1)\n+2] foo;\nendmodule",
-     "module foo;\n"
-     "  logic [`BAR(1)\n"
-     "+2] foo;\n"
-     "endmodule\n"},
-    {"module foo;\nlogic [`BAR(1)+2] foo;\nendmodule",
-     "module foo;\n"
-     "  logic [`BAR(1)+2] foo;\n"
-     "endmodule\n"},
-    {"module foo ();\n  function bar();\n    "
-     "logic [12:34] data[`AAAAAAAAAAAAAAAAAAAAAAAA(1) : "
-     "`BBBBBBBBBBBBBBBBBBBBBBBB(2) + 3];\n  "
-     "endfunction\nendmodule",
-     "module foo ();\n"
-     "  function bar();\n"
-     "    logic [12:34] data[\n"
-     "    `AAAAAAAAAAAAAAAAAAAAAAAA(1) :\n"
-     "    `BBBBBBBBBBBBBBBBBBBBBBBB(2) + 3];\n"
-     "  endfunction\n"
-     "endmodule\n"},
-    {
-        // test that alternate top-syntax mode works
-        "// verilog_syntax: parse-as-module-body\n"
-        "`define           FOO\n",
-        "// verilog_syntax: parse-as-module-body\n"
-        "`define FOO\n",
-    },
-    {
-        // test alternate parsing mode in macro expansion
-        "class foo;\n"
-        "`MY_MACRO(\n"
-        " // verilog_syntax: parse-as-statements\n"
-        " // EOL comment\n"
-        " int count;\n"
-        " if(cfg.enable) begin\n"
-        " count = 1;\n"
-        " end,\n"
-        " utils_pkg::decrement())\n"
-        "endclass\n",
-        "class foo;\n"
-        "  `MY_MACRO(\n"
-        "      // verilog_syntax: parse-as-statements\n"
-        "      // EOL comment\n"
-        "      int count;\n"
-        "      if (cfg.enable) begin\n"
-        "        count = 1;\n"
-        "      end, utils_pkg::decrement())\n"
-        "endclass\n",
-    },
-
-    // tests top-level data declarations
-    {"a;",  // implicit type
-     "a;\n"},
-    {"a\tb;",  // explicit type
-     "a b;\n"},
-    {"a;b;",
-     "a;\n"
-     "b;\n"},
-    {"a ,b;",  // implicit type
-     "a, b;\n"},
-    /* TODO(b/149591599): implicit type data declarations in module body
-    {"module\tm ;a ;endmodule",
-     "module m;\n"
-     "  a;\n"
-     "endmodule\n"},
-    */
-    {"package\tp ;a ;endpackage",  // implicit type
-     "package p;\n"
-     "  a;\n"
-     "endpackage\n"},
-    {"package\tp ;a ,b ;endpackage",  // implicit type
-     "package p;\n"
-     "  a, b;\n"
-     "endpackage\n"},
-    {"package\tp ;a ;b ;endpackage",  // implicit type
-     "package p;\n"
-     "  a;\n"
-     "  b;\n"
-     "endpackage\n"},
-    /* TODO(b/149591627) : implicit type data declarations in class body
-    {"class\tc ;a ;endclass",
-     "class c;\n"
-     "  a;\n"
-     "endclass\n"},
-     */
-    {"function\tf ;a ;endfunction",  // implicit type
-     "function f;\n"
-     "  a;\n"
-     "endfunction\n"},
-    {"function\tf ;a   ;x ;endfunction",  // implicit type
-     "function f;\n"
-     "  a;\n"
-     "  x;\n"
-     "endfunction\n"},
-    /* TODO(b/149592527): multi-variable data declaration as block_item_decl
-     // same inside tasks
-    {"function\tf ;a  \t,x ;endfunction",  // implicit type
-     "function f;\n"
-     "  a, x;\n"
-     "endfunction\n"},
-     */
-    {"task\tt ;a ;endtask",  // implicit type
-     "task t;\n"
-     "  a;\n"
-     "endtask\n"},
-    {"task\tt ;a   ;x ;endtask",  // implicit type
-     "task t;\n"
-     "  a;\n"
-     "  x;\n"
-     "endtask\n"},
-
-    {// tests bind declaration
-     "bind   foo   bar baz  ( . clk ( clk  ) ) ;",
-     "bind foo bar baz (.clk(clk));\n"},
-    {// tests bind declaration, with type params
-     "bind   foo   bar# ( . W ( W ) ) baz  ( . clk ( clk  ) ) ;",
-     "bind foo bar #(.W(W)) baz (.clk(clk));\n"},
-    {// tests bind declarations
-     "bind   foo   bar baz  ( ) ;"
-     "bind goo  car  caz (   );",
-     "bind foo bar baz ();\n"
-     "bind goo car caz ();\n"},
-
-    {"bind blah foo #( .MaxCount(MaxCount), .MaxDelta(MaxDelta)) bar ("
-     "    .clk(clk), .rst(rst), .value(value) );",
-     "bind blah foo #(\n"
-     "    .MaxCount(MaxCount),\n"
-     "    .MaxDelta(MaxDelta)\n"
-     ") bar (\n"
-     "    .clk  (clk),\n"
-     "    .rst  (rst),\n"
-     "    .value(value)\n"
-     ");\n"},
-    {"bind foo bar baz(\\\n"
-     "`undef d\\\n"
-     "`undef d);",
-     "bind foo bar baz (\\\n"
-     "    `undef d\\\n"
-     "    `undef d\n"
-     ");\n"},
-    {
-        "bind expaaaaaaaaaaand_meeee looooooooong_name# ("
-        ".W(W_CONST), .H(H_CONST), .D(D_CONST)  )"
-        "instaaance_name (.in(iiiiiiiin), .out(ooooooout), .clk(ccccccclk));",
-        "bind expaaaaaaaaaaand_meeee\n"
-        "    looooooooong_name #(\n"
-        "    .W(W_CONST),\n"
-        "    .H(H_CONST),\n"
-        "    .D(D_CONST)\n"
-        ") instaaance_name (\n"
-        "    .in (iiiiiiiin),\n"
-        "    .out(ooooooout),\n"
-        "    .clk(ccccccclk)\n"
-        ");\n",
-    },
-
-    {
-        "bind expand_inst name# ("
-        ".W(W_CONST), .H(H_CONST), .D(D_CONST)  )"
-        "instaaance_name (.in(iiiiiiiin), .out(ooooooout), .clk(ccccccclk));",
-        "bind expand_inst name #(\n"
-        "    .W(W_CONST),\n"
-        "    .H(H_CONST),\n"
-        "    .D(D_CONST)\n"
-        ") instaaance_name (\n"
-        "    .in (iiiiiiiin),\n"
-        "    .out(ooooooout),\n"
-        "    .clk(ccccccclk)\n"
-        ");\n",
-    },
-
-    {
-        // tests import declaration
-        "import  foo_pkg :: bar ;",
-        "import foo_pkg::bar;\n",
-    },
-    {
-        // tests import declaration with wildcard
-        "import  foo_pkg :: * ;",
-        "import foo_pkg::*;\n",
-    },
-    {
-        // tests import declarations
-        "import  foo_pkg :: *\t;"
-        "import  goo_pkg\n:: thing ;",
-        "import foo_pkg::*;\n"
-        "import goo_pkg::thing;\n",
-    },
-    // preserve spaces inside [] dimensions, but limit spaces around ':' to one
-    // and adjust everything else
-    {"foo[W-1:0]a[0:K-1];",  // data declaration
-     "foo [W-1:0] a[0:K-1];\n"},
-    {"foo[W-1 : 0]a[0 : K-1];", "foo [W-1 : 0] a[0 : K-1];\n"},
-    {"foo[W  -  1 : 0 ]a [ 0  :  K  -  1] ;",
-     "foo [W  -  1 : 0] a[0 : K  -  1];\n"},
-    // remove spaces between [...] [...] in multi-dimension arrays
-    {"foo[K] [W]a;",  //
-     "foo [K][W] a;\n"},
-    {"foo b [K] [W] ;",  //
-     "foo b[K][W];\n"},
-    {"logic[K:1] [W:1]a;",  //
-     "logic [K:1][W:1] a;\n"},
-    {"logic b [K:1] [W:1] ;",  //
-     "logic b[K:1][W:1];\n"},
-    // spaces in bit slicing
-    {
-        // preserve 0 spaces
-        "always_ff @(posedge clk) begin "
-        "dummy  <=\tfoo  [  7:2  ] ; "
-        "end",
-        "always_ff @(posedge clk) begin\n"
-        "  dummy <= foo[7:2];\n"
-        "end\n",
-    },
-    {
-        // preserve 1 space
-        "always_ff @(posedge clk) begin "
-        "dummy  <=\tfoo  [  7 : 2  ] ; "
-        "end",
-        "always_ff @(posedge clk) begin\n"
-        "  dummy <= foo[7 : 2];\n"
-        "end\n",
-    },
-    {
-        // limit multiple spaces to 1
-        "always_ff @(posedge clk) begin "
-        "dummy  <=\tfoo  [  7  :  2  ] ; "
-        "end",
-        "always_ff @(posedge clk) begin\n"
-        "  dummy <= foo[7 : 2];\n"
-        "end\n",
-    },
-    {
-        "always_ff @(posedge clk) begin "
-        "dummy  <=\tfoo  [  7  : 2  ] ; "
-        "end",
-        "always_ff @(posedge clk) begin\n"
-        "  dummy <= foo[7 : 2];\n"
-        "end\n",
-    },
-    {
-        // keep value on the left when symmetrizing
-        "always_ff @(posedge clk) begin "
-        "dummy  <=\tfoo  [  7: 2  ] ; "
-        "end",
-        "always_ff @(posedge clk) begin\n"
-        "  dummy <= foo[7:2];\n"
-        "end\n",
-    },
-    {
-        "always_ff @(posedge clk) begin "
-        "dummy  <=\tfoo  [  7:  2  ] ; "
-        "end",
-        "always_ff @(posedge clk) begin\n"
-        "  dummy <= foo[7:2];\n"
-        "end\n",
-    },
-    {
-        "always_ff @(posedge clk) begin "
-        "dummy  <=\tfoo  [  7 :2  ] ; "
-        "end",
-        "always_ff @(posedge clk) begin\n"
-        "  dummy <= foo[7 : 2];\n"
-        "end\n",
-    },
-    {
-        "always_ff @(posedge clk) begin "
-        "dummy  <=\tfoo  [  7 :  2  ] ; "
-        "end",
-        "always_ff @(posedge clk) begin\n"
-        "  dummy <= foo[7 : 2];\n"
-        "end\n",
-    },
-    {
-        // use value on the left, but limit to 1 space
-        "always_ff @(posedge clk) begin "
-        "dummy  <=\tfoo  [  7  :2  ] ; "
-        "end",
-        "always_ff @(posedge clk) begin\n"
-        "  dummy <= foo[7 : 2];\n"
-        "end\n",
-    },
-
-    // task test cases
-    {"task t ;endtask:t",  //
-     "task t;\n"
-     "endtask : t\n"},
-    {"task t ;#   10 ;# 5ns ; # 0.1 ; # 1step ;endtask",
-     "task t;\n"
-     "  #10;\n"  // no space in delay expression
-     "  #5ns;\n"
-     "  #0.1;\n"
-     "  #1step;\n"
-     "endtask\n"},
-    {"task t\n;a<=b ;c<=d ;endtask\n",
-     "task t;\n"
-     "  a <= b;\n"
-     "  c <= d;\n"
-     "endtask\n"},
-    {"class c;   virtual protected task\tt  ( foo bar);"
-     "a.a<=b.b;\t\tc.c\n<=   d.d; endtask   endclass",
-     "class c;\n"
-     "  virtual protected task t(foo bar);\n"
-     "    a.a <= b.b;\n"
-     "    c.c <= d.d;\n"
-     "  endtask\n"
-     "endclass\n"},
-    {"task t;\n// statement comment\nendtask\n",
-     "task t;\n"
-     "  // statement comment\n"  // indented
-     "endtask\n"},
-    {"task t( );\n// statement comment\nendtask\n",
-     "task t();\n"
-     "  // statement comment\n"  // indented
-     "endtask\n"},
-    {"task t( input x  );\n"
-     "// statement comment\n"
-     "s();\n"
-     "// statement comment\n"
-     "endtask\n",
-     "task t(input x);\n"
-     "  // statement comment\n"  // indented
-     "  s();\n"
-     "  // statement comment\n"  // indented
-     "endtask\n"},
-    {"task fj;fork join fork join\tendtask",
-     "task fj;\n"
-     "  fork\n"
-     "  join\n"
-     "  fork\n"
-     "  join\n"
-     "endtask\n"},
-    {"task fj;fork join_any fork join_any\tendtask",
-     "task fj;\n"
-     "  fork\n"
-     "  join_any\n"
-     "  fork\n"
-     "  join_any\n"
-     "endtask\n"},
-    {"task fj;fork join_none fork join_none\tendtask",
-     "task fj;\n"
-     "  fork\n"
-     "  join_none\n"
-     "  fork\n"
-     "  join_none\n"
-     "endtask\n"},
-    {"task fj;fork\n"
-     "//c1\njoin\n"
-     "//c2\n"
-     "fork  \n"
-     "//c3\n"
-     "join\tendtask",
-     "task fj;\n"
-     "  fork\n"
-     "    //c1\n"
-     "  join\n"
-     "  //c2\n"
-     "  fork\n"
-     "    //c3\n"
-     "  join\n"
-     "endtask\n"},
-    {"task fj;\n"
-     "fork "
-     "begin "
-     "end "
-     "foo();"
-     "begin "
-     "end "
-     "join_any endtask",
-     "task fj;\n"
-     "  fork\n"
-     "    begin\n"
-     "    end\n"
-     "    foo();\n"
-     "    begin\n"
-     "    end\n"
-     "  join_any\n"
-     "endtask\n"},
-    {
-        // call and assertion statements
-        "task  t ;Fire() ;assert ( x);assert(y );endtask",
-        "task t;\n"
-        "  Fire();\n"
-        "  assert (x);\n"
-        "  assert (y);\n"
-        "endtask\n",
-    },
-    {
-        // assertion statements with body clause
-        "task  t ;Fire() ;assert ( x) fee ( );assert(y ) foo ( ) ;endtask",
-        "task t;\n"
-        "  Fire();\n"
-        "  assert (x) fee();\n"
-        "  assert (y) foo();\n"
-        "endtask\n",
-    },
-    {
-        // assertion statements with else clause
-        "task  t ;Fire() ;assert ( x) else  fee ( );"
-        "assert(y ) else  foo ( ) ;endtask",
-        "task t;\n"
-        "  Fire();\n"
-        "  assert (x)\n"
-        "  else fee();\n"
-        "  assert (y)\n"
-        "  else foo();\n"
-        "endtask\n",
-    },
-    {
-        // assertion statements with else clause
-        "task  t ;Fire() ;assert ( x) fa(); else  fee ( );"
-        "assert(y ) fi(); else  foo ( ) ;endtask",
-        "task t;\n"
-        "  Fire();\n"
-        "  assert (x) fa();\n"
-        "  else fee();\n"
-        "  assert (y) fi();\n"
-        "  else foo();\n"
-        "endtask\n",
-    },
-    {
-        // assume statements
-        "task  t ;Fire() ;assume ( x);assume(y );endtask",
-        "task t;\n"
-        "  Fire();\n"
-        "  assume (x);\n"
-        "  assume (y);\n"
-        "endtask\n",
-    },
-    {
-        // cover statements
-        "task  t ;Fire() ;cover ( x);cover(y );endtask",
-        "task t;\n"
-        "  Fire();\n"
-        "  cover (x);\n"
-        "  cover (y);\n"
-        "endtask\n",
-    },
-    {
-        // cover statements, with action
-        "task  t ;Fire() ;cover ( x)g( );cover(y ) h();endtask",
-        "task t;\n"
-        "  Fire();\n"
-        "  cover (x) g();\n"
-        "  cover (y) h();\n"
-        "endtask\n",
-    },
-    {
-        // cover statements, with action block
-        "task  t ;Fire() ;cover ( x) begin g( ); end "
-        "cover(y ) begin h(); end endtask",
-        "task t;\n"
-        "  Fire();\n"
-        "  cover (x) begin\n"
-        "    g();\n"
-        "  end\n"
-        "  cover (y) begin\n"
-        "    h();\n"
-        "  end\n"
-        "endtask\n",
-    },
-    {// shuffle calls
-     "task t; foo. shuffle  ( );bar .shuffle( ); endtask",
-     "task t;\n"
-     "  foo.shuffle();\n"
-     "  bar.shuffle();\n"
-     "endtask\n"},
-    {// wait statements (null)
-     "task t; wait  (a==b);wait(c<d); endtask",
-     "task t;\n"
-     "  wait (a == b);\n"
-     "  wait (c < d);\n"
-     "endtask\n"},
-    {// wait statements, single action statement
-     "task t; wait  (a==b) p();wait(c<d) q(); endtask",
-     "task t;\n"
-     "  wait (a == b) p();\n"
-     "  wait (c < d) q();\n"
-     "endtask\n"},
-    {// wait statements, block action statement
-     "task t; wait  (a==b) begin p(); end "
-     "wait(c<d) begin q(); end endtask",
-     "task t;\n"
-     "  wait (a == b) begin\n"
-     "    p();\n"
-     "  end\n"
-     "  wait (c < d) begin\n"
-     "    q();\n"
-     "  end\n"
-     "endtask\n"},
-    {// wait fork statements
-     "task t ; wait\tfork;wait   fork ;endtask",
-     "task t;\n"
-     "  wait fork;\n"
-     "  wait fork;\n"
-     "endtask\n"},
-    {// labeled single statements (prefix-style)
-     "task t;l1:x<=y ;endtask",
-     "task t;\n"
-     "  l1 : x <= y;\n"
-     "endtask\n"},
-    {// labeled block statements (prefix-style)
-     "task t;l1:begin end:l1 endtask",
-     "task t;\n"
-     "  l1 : begin\n"
-     "  end : l1\n"
-     "endtask\n"},
-    {// labeled seq block statements
-     "task t;begin:l1 end:l1 endtask",
-     "task t;\n"
-     "  begin : l1\n"
-     "  end : l1\n"
-     "endtask\n"},
-    {// labeled par block statements
-     "task t;fork:l1 join:l1 endtask",
-     "task t;\n"
-     "  fork : l1\n"
-     "  join : l1\n"
-     "endtask\n"},
-    {// task with disable statements
-     "task  t ;fork\tjoin\tdisable\tfork;endtask",
-     "task t;\n"
-     "  fork\n"
-     "  join\n"
-     "  disable fork;\n"
-     "endtask\n"},
-    {"task  t ;fork\tjoin_any\tdisable\tfork  ;endtask",
-     "task t;\n"
-     "  fork\n"
-     "  join_any\n"
-     "  disable fork;\n"
-     "endtask\n"},
-    {"task  t ;disable\tbean_counter  ;endtask",
-     "task t;\n"
-     "  disable bean_counter;\n"
-     "endtask\n"},
-    {
-        // task with if-statement
-        "task t;"
-        "if (r == t)"
-        "a.b(c);"
-        "endtask",
-        "task t;\n"
-        "  if (r == t) a.b(c);\n"
-        "endtask\n",
-    },
-    {
-        // task with system call inside if header
-        "task t;"
-        "if (!$cast(ssssssssssssssss,vvvvvvvvvv,gggggggg))begin end endtask:t",
-        "task t;\n"
-        "  if (!$cast(\n"
-        "          ssssssssssssssss,\n"
-        "          vvvvvvvvvv,\n"
-        "          gggggggg\n"
-        "      )) begin\n"
-        "  end\n"
-        "endtask : t\n",
-    },
-    {
-        // task with nested subtask call and arguments passed by name
-        "task t;"
-        "if (!$cast(ssssssssssssssss, vvvvvvvvvv.gggggggg("
-        ".ppppppp(ppppppp),"
-        ".yyyyy(\"xxxxxxxxxxxxx\")"
-        "))) begin "
-        "end "
-        "endtask : t",
-        "task t;\n"
-        "  if (!$cast(\n"
-        "          ssssssssssssssss,\n"
-        "          vvvvvvvvvv.gggggggg(\n"
-        "              .ppppppp(ppppppp),\n"
-        "              .yyyyy(\"xxxxxxxxxxxxx\")\n"
-        "          )\n"
-        "      )) begin\n"
-        "  end\n"
-        "endtask : t\n",
-    },
-
-    {
-        // assert property statements
-        "task  t ;assert  property( x);assert\tproperty(y );endtask",
-        "task t;\n"
-        "  assert property (x);\n"
-        "  assert property (y);\n"
-        "endtask\n",
-    },
-    {
-        // assert property statements, with action
-        "task  t ;assert  property( x) j();assert\tproperty(y )k( );endtask",
-        "task t;\n"
-        "  assert property (x) j();\n"
-        "  assert property (y) k();\n"
-        "endtask\n",
-    },
-    {
-        // assert property statements, with action block
-        "task  t ;assert  property( x) begin j();end "
-        " assert\tproperty(y )begin\tk( );  end endtask",
-        "task t;\n"
-        "  assert property (x) begin\n"
-        "    j();\n"
-        "  end\n"
-        "  assert property (y) begin\n"
-        "    k();\n"
-        "  end\n"
-        "endtask\n",
-    },
-    {
-        // assert property statements, else with null
-        "task  t ;assert  property( x) else;assert\tproperty(y )else;endtask",
-        "task t;\n"
-        "  assert property (x)\n"
-        "  else;\n"
-        "  assert property (y)\n"
-        "  else;\n"
-        "endtask\n",
-    },
-    {
-        // assert property statements, else with actions
-        "task  t ;assert  property( x) f(); else p(); "
-        "\tassert\tproperty(y ) g();else  q( );endtask",
-        "task t;\n"
-        "  assert property (x) f();\n"
-        "  else p();\n"
-        "  assert property (y) g();\n"
-        "  else q();\n"
-        "endtask\n",
-    },
-    {
-        // assert property statement, with action block, else statement
-        "task  t ;assert  property( x) begin j();end  else\tk( );  endtask",
-        "task t;\n"
-        "  assert property (x) begin\n"
-        "    j();\n"
-        "  end else k();\n"
-        "endtask\n",
-    },
-    {
-        // assert property statement, with action statement, else block
-        "task  t ;assert  property( x) j();  else  begin\tk( );end  endtask",
-        "task t;\n"
-        "  assert property (x) j();\n"
-        "  else begin\n"
-        "    k();\n"
-        "  end\n"
-        "endtask\n",
-    },
-    {
-        // assert property statement, with action block, else block
-        "task  t ;assert  property( x)begin j();end  "
-        "else  begin\tk( );end  endtask",
-        "task t;\n"
-        "  assert property (x) begin\n"
-        "    j();\n"
-        "  end else begin\n"
-        "    k();\n"
-        "  end\n"
-        "endtask\n",
-    },
-
-    {
-        // assume property statements
-        "task  t ;assume  property( x);assume\tproperty(y );endtask",
-        "task t;\n"
-        "  assume property (x);\n"
-        "  assume property (y);\n"
-        "endtask\n",
-    },
-    {
-        // assume property statements, with action
-        "task  t ;assume  property( x) j();assume\tproperty(y )k( );endtask",
-        "task t;\n"
-        "  assume property (x) j();\n"
-        "  assume property (y) k();\n"
-        "endtask\n",
-    },
-    {
-        // assume property statements, with action block
-        "task  t ;assume  property( x) begin j();end "
-        " assume\tproperty(y )begin\tk( );  end endtask",
-        "task t;\n"
-        "  assume property (x) begin\n"
-        "    j();\n"
-        "  end\n"
-        "  assume property (y) begin\n"
-        "    k();\n"
-        "  end\n"
-        "endtask\n",
-    },
-    {
-        // assume property statements, else with null
-        "task  t ;assume  property( x) else;assume\tproperty(y )else;endtask",
-        "task t;\n"
-        "  assume property (x)\n"
-        "  else;\n"
-        "  assume property (y)\n"
-        "  else;\n"
-        "endtask\n",
-    },
-    {
-        // assume property statements, else with actions
-        "task  t ;assume  property( x) f(); else p(); "
-        "\tassume\tproperty(y ) g();else  q( );endtask",
-        "task t;\n"
-        "  assume property (x) f();\n"
-        "  else p();\n"
-        "  assume property (y) g();\n"
-        "  else q();\n"
-        "endtask\n",
-    },
-    {
-        // assume property statement, with action block, else statement
-        "task  t ;assume  property( x) begin j();end  else\tk( );  endtask",
-        "task t;\n"
-        "  assume property (x) begin\n"
-        "    j();\n"
-        "  end else k();\n"
-        "endtask\n",
-    },
-    {
-        // assume property statement, with action statement, else block
-        "task  t ;assume  property( x) j();  else  begin\tk( );end  endtask",
-        "task t;\n"
-        "  assume property (x) j();\n"
-        "  else begin\n"
-        "    k();\n"
-        "  end\n"
-        "endtask\n",
-    },
-    {
-        // assume property statement, with action block, else block
-        "task  t ;assume  property( x)begin j();end  "
-        "else  begin\tk( );end  endtask",
-        "task t;\n"
-        "  assume property (x) begin\n"
-        "    j();\n"
-        "  end else begin\n"
-        "    k();\n"
-        "  end\n"
-        "endtask\n",
-    },
-
-    {
-        // expect property statements
-        "task  t ;expect  ( x);expect\t(y );endtask",
-        "task t;\n"
-        "  expect (x);\n"
-        "  expect (y);\n"
-        "endtask\n",
-    },
-    {
-        // expect property statements, with action
-        "task  t ;expect  ( x) j();expect\t(y )k( );endtask",
-        "task t;\n"
-        "  expect (x) j();\n"
-        "  expect (y) k();\n"
-        "endtask\n",
-    },
-    {
-        // expect property statements, with action block
-        "task  t ;expect  ( x) begin j();end "
-        " expect\t(y )begin\tk( );  end endtask",
-        "task t;\n"
-        "  expect (x) begin\n"
-        "    j();\n"
-        "  end\n"
-        "  expect (y) begin\n"
-        "    k();\n"
-        "  end\n"
-        "endtask\n",
-    },
-    {
-        // expect property statements, else with null
-        "task  t ;expect  ( x) else;expect\t(y )else;endtask",
-        "task t;\n"
-        "  expect (x)\n"
-        "  else;\n"
-        "  expect (y)\n"
-        "  else;\n"
-        "endtask\n",
-    },
-    {
-        // expect property statements, else with actions
-        "task  t ;expect  ( x) f(); else p(); "
-        "\texpect\t(y ) g();else  q( );endtask",
-        "task t;\n"
-        "  expect (x) f();\n"
-        "  else p();\n"
-        "  expect (y) g();\n"
-        "  else q();\n"
-        "endtask\n",
-    },
-    {
-        // expect property statement, with action block, else statement
-        "task  t ;expect  ( x) begin j();end  else\tk( );  endtask",
-        "task t;\n"
-        "  expect (x) begin\n"
-        "    j();\n"
-        "  end else k();\n"
-        "endtask\n",
-    },
-    {
-        // expect property statement, with action statement, else block
-        "task  t ;expect  ( x) j();  else  begin\tk( );end  endtask",
-        "task t;\n"
-        "  expect (x) j();\n"
-        "  else begin\n"
-        "    k();\n"
-        "  end\n"
-        "endtask\n",
-    },
-    {
-        // expect property statement, with action block, else block
-        "task  t ;expect  ( x)begin j();end  "
-        "else  begin\tk( );end  endtask",
-        "task t;\n"
-        "  expect (x) begin\n"
-        "    j();\n"
-        "  end else begin\n"
-        "    k();\n"
-        "  end\n"
-        "endtask\n",
-    },
-
-    {
-        // cover property statements
-        "task  t ;cover  property( x);cover\tproperty(y );endtask",
-        "task t;\n"
-        "  cover property (x);\n"
-        "  cover property (y);\n"
-        "endtask\n",
-    },
-    {
-        // cover property statements, with action
-        "task  t ;cover  property( x) j();cover\tproperty(y )k( );endtask",
-        "task t;\n"
-        "  cover property (x) j();\n"
-        "  cover property (y) k();\n"
-        "endtask\n",
-    },
-    {
-        // cover property statements, with action block
-        "task  t ;cover  property( x) begin j();end "
-        " cover\tproperty(y )begin\tk( );  end endtask",
-        "task t;\n"
-        "  cover property (x) begin\n"
-        "    j();\n"
-        "  end\n"
-        "  cover property (y) begin\n"
-        "    k();\n"
-        "  end\n"
-        "endtask\n",
-    },
-
-    {
-        // cover sequence statements
-        "task  t ;cover  sequence( x);cover\tsequence(y );endtask",
-        "task t;\n"
-        "  cover sequence (x);\n"
-        "  cover sequence (y);\n"
-        "endtask\n",
-    },
-    {
-        // cover sequence statements, with action
-        "task  t ;cover  sequence( x) j();cover\tsequence(y )k( );endtask",
-        "task t;\n"
-        "  cover sequence (x) j();\n"
-        "  cover sequence (y) k();\n"
-        "endtask\n",
-    },
-    {
-        // cover sequence statements, with action block
-        "task  t ;cover  sequence( x) begin j();end "
-        " cover\tsequence(y )begin\tk( );  end endtask",
-        "task t;\n"
-        "  cover sequence (x) begin\n"
-        "    j();\n"
-        "  end\n"
-        "  cover sequence (y) begin\n"
-        "    k();\n"
-        "  end\n"
-        "endtask\n",
-    },
-
-    {// module with disable statements
-     "module m;always begin :block disable m.block; end endmodule",
-     "module m;\n"
-     "  always begin : block\n"
-     "    disable m.block;\n"
-     "  end\n"
-     "endmodule\n"},
-    {"module m;always begin disable m.block; end endmodule",
-     "module m;\n"
-     "  always begin\n"
-     "    disable m.block;\n"
-     "  end\n"
-     "endmodule\n"},
-
-    // property test cases
-    {"module mp ;property p1 ; a|->b;endproperty endmodule",
-     "module mp;\n"
-     "  property p1;\n"
-     "    a |-> b;\n"
-     "  endproperty\n"
-     "endmodule\n"},
-    {"module mp ;property p1 ; a|->b;endproperty:p1 endmodule",
-     "module mp;\n"
-     "  property p1;\n"
-     "    a |-> b;\n"
-     "  endproperty : p1\n"  // with end label
-     "endmodule\n"},
-    {"module mp ;property p1 ; a|->## 1  b;endproperty endmodule",
-     "module mp;\n"
-     "  property p1;\n"
-     "    a |-> ##1 b;\n"  // with delay
-     "  endproperty\n"
-     "endmodule\n"},
-    {"module mp ;property p1 ; a|->## [0: 1]  b;endproperty endmodule",
-     "module mp;\n"
-     "  property p1;\n"
-     "    a |-> ##[0:1] b;\n"  // prefer no spaces with delay range
-     "  endproperty\n"
-     "endmodule\n"},
-    {"module mp ;property p1 ; a|->## [0  : 1]  b;endproperty endmodule",
-     "module mp;\n"
-     "  property p1;\n"
-     "    a |-> ##[0 : 1] b;\n"  // limit to one space, symmetrize
-     "  endproperty\n"
-     "endmodule\n"},
-    {"module mp ;property p1 ; a## 1  b;endproperty endmodule",
-     "module mp;\n"
-     "  property p1;\n"
-     "    a ##1 b;\n"
-     "  endproperty\n"
-     "endmodule\n"},
-    {"module mp ;property p1 ; (a^c)## 1  b;endproperty endmodule",
-     "module mp;\n"
-     "  property p1;\n"
-     "    (a ^ c) ##1 b;\n"
-     "  endproperty\n"
-     "endmodule\n"},
-
-    // covergroup test cases
-    {// Minimal case
-     "covergroup c; endgroup\n",
-     "covergroup c;\n"
-     "endgroup\n"},
-    {// Minimal useful case
-     "covergroup c @ (posedge clk); coverpoint a; endgroup\n",
-     "covergroup c @(posedge clk);\n"
-     "  coverpoint a;\n"
-     "endgroup\n"},
-    {// Multiple coverpoints
-     "covergroup foo @(posedge clk); coverpoint a; coverpoint b; "
-     "coverpoint c; coverpoint d; endgroup\n",
-     "covergroup foo @(posedge clk);\n"
-     "  coverpoint a;\n"
-     "  coverpoint b;\n"
-     "  coverpoint c;\n"
-     "  coverpoint d;\n"
-     "endgroup\n"},
-    {// Multiple bins
-     "covergroup memory @ (posedge ce); address  :coverpoint addr {"
-     "bins low={0,127}; bins high={128,255};} endgroup\n",
-     "covergroup memory @(posedge ce);\n"
-     "  address: coverpoint addr {\n"
-     "    bins low = {0, 127};\n"
-     "    bins high = {128, 255};\n"
-     "  }\n"
-     "endgroup\n"},
-    {// Custom sample() function
-     "covergroup c with function sample(bit i); endgroup\n",
-     "covergroup c with function sample (\n"
-     "    bit i\n"  // test cases are wrapped at 40
-     ");\n"
-     "endgroup\n"},
-
-    // comment-controlled formatter disabling
-    {"// verilog_format: off\n"  // disables whole file
-     "  `include  \t\t  \"path/to/file.vh\"\n",
-     "// verilog_format: off\n"
-     "  `include  \t\t  \"path/to/file.vh\"\n"},  // keeps bad spacing
-    {"/* verilog_format: off */\n"                // disables whole file
-     "  `include  \t\t  \"path/to/file.svh\"  \n",
-     "/* verilog_format: off */\n"
-     "  `include  \t\t  \"path/to/file.svh\"  \n"},  // keeps bad spacing
-    {"// verilog_format: on\n"  // already enabled, no effect
-     "  `include  \t  \"path/to/file.svh\"  \t\n",
-     "// verilog_format: on\n"
-     "`include \"path/to/file.svh\"\n"},
-    {"// verilog_format: off\n"
-     "// verilog_format: on\n"  // re-enable right away
-     "  `include  \t\t  \"path/to/file.svh\"  \n",
-     "// verilog_format: off\n"
-     "// verilog_format: on\n"
-     "`include \"path/to/file.svh\"\n"},
-    {"/* aaa *//* bbb */\n"                         // not formatting controls
-     "  `include  \t\t  \"path/to/file.svh\"  \n",  // should format
-     "/* aaa */  /* bbb */\n"  // currently inserts 2 spaces
-     "`include \"path/to/file.svh\"\n"},
-    {"/* verilog_format: off *//* verilog_format: on */\n"  // re-enable
-     "  `include  \t\t  \"path/to/file.svh\"  \n",
-     // Note that this case normally wouldn't fit in 40 columns,
-     // but disabling formatting lets it overflow.
-     "/* verilog_format: off *//* verilog_format: on */\n"
-     "`include \"path/to/file.svh\"\n"},
-    {"// verilog_format: off\n"
-     "  `include  \t\t  \"path/to/fileA.svh\"  // verilog_format: on\n"
-     "  `include  \t\t  \"path/to/fileB.svh\"  \n",
-     // re-enable formatting with comment trailing other tokens
-     "// verilog_format: off\n"
-     "  `include  \t\t  \"path/to/fileA.svh\"  // verilog_format: on\n"
-     "`include \"path/to/fileB.svh\"\n"},
-    {"  `include  \t\t  \"path/to/file1.vh\" \n"  // format this
-     "// verilog_format: off\n"                   // start disabling
-     "  `include  \t\t  \"path/to/file2.vh\" \n"
-     "\t\t\n"
-     "  `include  \t\t  \"path/to/file3.vh\" \n"
-     "// verilog_format: on\n"                     // stop disabling
-     "  `include  \t\t  \"path/to/file4.vh\" \n",  // format this
-     "`include \"path/to/file1.vh\"\n"
-     "// verilog_format: off\n"  // start disabling
-     "  `include  \t\t  \"path/to/file2.vh\" \n"
-     "\t\t\n"
-     "  `include  \t\t  \"path/to/file3.vh\" \n"
-     "// verilog_format: on\n"  // stop disabling
-     "`include \"path/to/file4.vh\"\n"},
-    {// disabling formatting on a module (to end of file)
-     "// verilog_format: off\n"
-     "module m;endmodule\n",
-     "// verilog_format: off\n"
-     "module m;endmodule\n"},
-    {// disabling formatting on a module (to end of file)
-     "// verilog_format: off\n"
-     "module m;\n"
-     "unindented instantiation;\n"
-     "endmodule\n",
-     "// verilog_format: off\n"
-     "module m;\n"
-     "unindented instantiation;\n"
-     "endmodule\n"},
-    {// disabling formatting inside a port declaration list disables alignment,
-     // but falls back to standard compaction.
-     "module align_off(\n"
-     "input w  ,\n"
-     "    // verilog_format: off\n"
-     "input wire  [y:z] wwww,\n"
-     "    // verilog_format: on\n"
-     "output  reg    xx\n"
-     ");\n"
-     "endmodule",
-     "module align_off (\n"
-     "    input w  ,\n"  // preserved because group is partially disabled
-     "    // verilog_format: off\n"
-     "input wire  [y:z] wwww,\n"  // not compacted
-     "    // verilog_format: on\n"
-     "    output  reg    xx\n"  // preserved because group is partially disabled
-     ");\n"
-     "endmodule\n"},
-
-    {// multiple tokens with EOL comment
-     "module please;  // don't break before the comment\n"
-     "endmodule\n",
-     "module please\n"
-     "    ;  // don't break before the comment\n"
-     "endmodule\n"},
-    {// one token with EOL comment
-     "module please;\n"
-     "endmodule  // don't break before the comment\n",
-     "module please;\n"
-     "endmodule  // don't break before the comment\n"},
-    {
-        // line with only an EOL comment
-        "module wild;\n"
-        "// a really long comment on its own line to be left alone\n"
-        "endmodule",
-        "module wild;\n"
-        "  // a really long comment on its own line to be left alone\n"
-        "endmodule\n",
-    },
-    {
-        // primitive declaration
-        "primitive primitive1(o, s, r);output o;reg o;input s;input r;table 1 "
-        "? :"
-        " ? : 0; ? 1    : 0   : -; endtable endprimitive",
-        "primitive primitive1(o, s, r);\n"
-        "  output o;\n"
-        "  reg o;\n"
-        "  input s;\n"
-        "  input r;\n"
-        "  table\n"
-        "    1 ? : ? : 0;\n"
-        "    ? 1 : 0 : -;\n"
-        "  endtable\n"
-        "endprimitive\n",
-    },
-    {
-        // one-input combinatorial UDP
-        "primitive primitive1 ( o,i ) ;output o;input i;"
-        " table 1  :   0 ;   0  :  1 ; endtable endprimitive",
-        "primitive primitive1(o, i);\n"
-        "  output o;\n"
-        "  input i;\n"
-        "  table\n"
-        "    1 : 0;\n"
-        "    0 : 1;\n"
-        "  endtable\n"
-        "endprimitive\n",
-    },
-    {
-        // two-input combinatorial UDP
-        "primitive primitive2(o, s, r);output o;input s;input r;"
-        "table 1 ? : 0;? 1 : -; endtable endprimitive",
-        "primitive primitive2(o, s, r);\n"
-        "  output o;\n"
-        "  input s;\n"
-        "  input r;\n"
-        "  table\n"
-        "    1 ? : 0;\n"
-        "    ? 1 : -;\n"
-        "  endtable\n"
-        "endprimitive\n",
-    },
-    {
-        // ten-input combinatorial UDP
-        "primitive comb10(o, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);"
-        "output o;input i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;"
-        "table 0 ? ? ? ? ? ? ? ? 0 : 0;1 ? ? ? ? ? ? ? ? 0 : 1;"
-        "1 ? ? ? ? ? ? ? ? 1 : 1;0 ? ? ? ? ? ? ? ? 1 : 0;endtable endprimitive",
-        "primitive comb10(o, i0, i1, i2, i3, i4,\n"
-        "                 i5, i6, i7, i8, i9);\n"
-        "  output o;\n"
-        "  input i0, i1, i2, i3, i4, i5, i6, i7,\n"
-        "      i8, i9;\n"
-        "  table\n"
-        "    0 ? ? ? ? ? ? ? ? 0 : 0;\n"
-        "    1 ? ? ? ? ? ? ? ? 0 : 1;\n"
-        "    1 ? ? ? ? ? ? ? ? 1 : 1;\n"
-        "    0 ? ? ? ? ? ? ? ? 1 : 0;\n"
-        "  endtable\n"
-        "endprimitive\n",
-    },
-    {
-        // sequential level-sensitive UDP
-        "primitive level_seq(o, c, d);output o;reg o;"
-        "  input c;input d;table\n"
-        "//  C D  state O\n"
-        "0   ? : ? :  -;  // No Change\n"
-        "? 0   : 0 :  0;  // Unknown\n"
-        "endtable endprimitive",
-        "primitive level_seq(o, c, d);\n"
-        "  output o;\n"
-        "  reg o;\n"
-        "  input c;\n"
-        "  input d;\n"
-        "  table\n"
-        "    //  C D  state O\n"
-        "    0 ? : ? : -;  // No Change\n"
-        "    ? 0 : 0 : 0;  // Unknown\n"
-        "  endtable\n"
-        "endprimitive\n",
-    },
-    {
-        // sequential edge-sensitive UDP
-        "primitive edge_seq(o, c, d);output o;reg o;input c;input d;"
-        "table (01) 0 : ? :  0;(01) 1 : ? :  1;(0?) 1 : 1 :  1;(0?) 0 : 0 :  "
-        "0;\n"
-        "// ignore negative c\n"
-        "(?0) ? : ? :  -;\n"
-        "// ignore changes on steady c\n"
-        "?  (?\?) : ? :  -; endtable endprimitive",
-        "primitive edge_seq(o, c, d);\n"
-        "  output o;\n"
-        "  reg o;\n"
-        "  input c;\n"
-        "  input d;\n"
-        "  table\n"
-        "    (01) 0 : ? : 0;\n"
-        "    (01) 1 : ? : 1;\n"
-        "    (0?) 1 : 1 : 1;\n"
-        "    (0?) 0 : 0 : 0;\n"
-        "    // ignore negative c\n"
-        "    (?0) ? : ? : -;\n"
-        "    // ignore changes on steady c\n"
-        "    ? (?\?) : ? : -;\n"
-        "  endtable\n"
-        "endprimitive\n",
-    },
-    {
-        // mixed sequential UDP
-        "primitive mixed(o, clk, j, k, preset, clear);output o;reg o;"
-        "input c;input j, k;input preset, clear;table "
-        "?  ??  01:?:1 ; // preset logic\n"
-        "?  ??  *1:1:1 ;?  ??  10:?:0 ; // clear logic\n"
-        "?  ??  1*:0:0 ;r  00  00:0:1 ; // normal\n"
-        "r  00  11:?:- ;r  01  11:?:0 ;r  10  11:?:1 ;r  11  11:0:1 ;"
-        "r  11  11:1:0 ;f  ??  ??:?:- ;b  *?  ??:?:- ;"
-        " // j and k\n"
-        "b  ?*  ??:?:- ;endtable endprimitive\n",
-        "primitive mixed(o, clk, j, k, preset,\n"
-        "                clear);\n"
-        "  output o;\n"
-        "  reg o;\n"
-        "  input c;\n"
-        "  input j, k;\n"
-        "  input preset, clear;\n"
-        "  table\n"
-        "    ? ? ? 0 1 : ? : 1;  // preset logic\n"
-        "    ? ? ? * 1 : 1 : 1;\n"
-        "    ? ? ? 1 0 : ? : 0;  // clear logic\n"
-        "    ? ? ? 1 * : 0 : 0;\n"
-        "    r 0 0 0 0 : 0 : 1;  // normal\n"
-        "    r 0 0 1 1 : ? : -;\n"
-        "    r 0 1 1 1 : ? : 0;\n"
-        "    r 1 0 1 1 : ? : 1;\n"
-        "    r 1 1 1 1 : 0 : 1;\n"
-        "    r 1 1 1 1 : 1 : 0;\n"
-        "    f ? ? ? ? : ? : -;\n"
-        "    b * ? ? ? : ? : -;  // j and k\n"
-        "    b ? * ? ? : ? : -;\n"
-        "  endtable\n"
-        "endprimitive\n",
-    },
-    // un-lexed multiline macro arg token
-    {
-        " task  S ; "
-        "`ppgJH3JoxhwyTmZ2dgPiuMQzpRAWiSs("
-        "{xYtxuh6.FIMcVPEWfhtoI2FSe, xYtxuh6.ZVL5XASVGLYz32} == "
-        "SqRgavM[15:2];\n"
-        "JgQLBG == 4'h0;, \"foo\" )\n"
-        "endtask\n",
-        "task S;\n"
-        "  `ppgJH3JoxhwyTmZ2dgPiuMQzpRAWiSs(\n"
-        "      {xYtxuh6.FIMcVPEWfhtoI2FSe, xYtxuh6.ZVL5XASVGLYz32} == "
-        "SqRgavM[15:2];\n"
-        "JgQLBG == 4'h0;,\n"
-        "      \"foo\")\n"
-        "endtask\n",
-    },
-
-    // module instantiation named ports tabular alignment
-    //{// module instantiation with no port, only comments
-    //    "module m;\n"
-    //    "foo bar(\n"
-    //    "\t//comment1\n"
-    //    "//comment2\n"
-    //    ");\n"
-    //    "endmodule\n",
-    //    "module m;\n"
-    //    "  foo bar (\n"
-    //    "      //comment1\n"
-    //    "      //comment2\n"
-    //    "  );\n"
-    //    "endmodule\n"
-    //},
-    {// all named ports
-     "module m;\n"
-     "foo bar(.a(a), .aa(aa), .aaa(aaa));\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),\n"
-     "      .aa (aa),\n"
-     "      .aaa(aaa)\n"
-     "  );\n"
-     "endmodule\n"},
-    {// named ports left unconnected
-     "module m;\n"
-     "foo bar(.a(), .aa(), .aaa());\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (),\n"
-     "      .aa (),\n"
-     "      .aaa()\n"
-     "  );\n"
-     "endmodule\n"},
-    {// multiple named ports groups separated by blank line
-     "module m;\n"
-     "foo bar(.a(a), .aaa(aaa),\n\n .b(b), .bbbbbb(bbbbb));\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),\n"
-     "      .aaa(aaa),\n"
-     "\n"
-     "      .b     (b),\n"
-     "      .bbbbbb(bbbbb)\n"
-     "  );\n"
-     "endmodule\n"},
-    {// named ports with concatenation
-     "module m;\n"
-     "foo bar(.a(a), .aaa({a,b,c}));\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),\n"
-     "      .aaa({a, b, c})\n"
-     "  );\n"
-     "endmodule\n"},
-    {// name ports with slices
-     "module m;\n"
-     "foo bar(.a(a), .aaa(q[r:s]));\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),\n"
-     "      .aaa(q[r:s])\n"
-     "  );\n"
-     "endmodule\n"},
-    {// named ports with pre-proc directives
-     "module m;\n"
-     "foo bar(.a(a), `ifdef MACRO .aa(aa), `endif .aaa(aaa));\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),\n"
-     "`ifdef MACRO\n"
-     "      .aa (aa),\n"
-     "`endif\n"
-     "      .aaa(aaa)\n"
-     "  );\n"
-     "endmodule\n"},
-    {// named ports with macros
-     "module m;\n"
-     "foo bar(.a(a), .aa(aa[`RANGE]), .aaa(aaa));\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),\n"
-     "      .aa (aa[`RANGE]),\n"
-     "      .aaa(aaa)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "foo bar(.a(a), .AA, .aaa(aaa));\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),\n"
-     "      .AA,\n"
-     "      .aaa(aaa)\n"
-     "  );\n"
-     "endmodule\n"},
-    {// name ports with comments
-     "module m;\n"
-     "foo bar(.a(a), .aa(aa)/*comment*/, .aaa(aaa));\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),\n"
-     "      .aa (aa)  /*comment*/,\n"
-     "      .aaa(aaa)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "foo bar(.a(a),//comment1\n .aaa(aaa)//comment2\n);\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),   //comment1\n"
-     "      .aaa(aaa)  //comment2\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "foo bar(.a(a),\n"
-     " //.aa(aa),\n"
-     ".aaa(aaa));\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),\n"
-     "      //.aa(aa),\n"
-     "      .aaa(aaa)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "foo bar(\n"
-     ".a(a) //comment1\n"
-     ", .aaa(aaa) //comment2\n"
-     ") //comment3\n"
-     ";\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "        .a  (a)    //comment1\n"
-     "      , .aaa(aaa)  //comment2\n"
-     "  )  //comment3\n"
-     "  ;\n"
-     "endmodule\n"},
-    {// module instantiation with all implicit connections
-     "module m;\n"
-     "foo bar(.a, .aa, .aaaaa);\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a,\n"
-     "      .aa,\n"
-     "      .aaaaa\n"
-     "  );\n"
-     "endmodule\n"},
-    {// named ports corssed with implicit connections
-     "module m;\n"
-     "foo bar(.a(a), .aa, .aaaaa(aaaaa));\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a    (a),\n"
-     "      .aa,\n"
-     "      .aaaaa(aaaaa)\n"
-     "  );\n"
-     "endmodule\n"},
-    {// named ports corssed with wildcard connections
-     "module m;\n"
-     "foo bar(.a(a), .aaa(aaa), .*);\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),\n"
-     "      .aaa(aaa),\n"
-     "      .*\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "foo bar(.a(a), .aa(aa), .* , .aaa(aaa));\n"
-     "endmodule\n",
-     "module m;\n"
-     "  foo bar (\n"
-     "      .a  (a),\n"
-     "      .aa (aa),\n"
-     "      .*,\n"
-     "      .aaa(aaa)\n"
-     "  );\n"
-     "endmodule\n"},
-
-    // Parameterized data types, declarations inside #() tabular alignment
-    {// parameterized module with 'list_of_param_assignments'
-     "module foo #(A = 2, AA = 22, AAA = 222);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    A   = 2,\n"
-     "    AA  = 22,\n"
-     "    AAA = 222\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'parameter_declaration'
-     "module foo #(parameter int a = 2, parameter int aa = 22);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    parameter int a  = 2,\n"
-     "    parameter int aa = 22\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'parameter_declaration' and comments
-     "module foo #(//comment\nparameter int a = 2, parameter int aa = 22);\n"
-     "endmodule\n",
-     "module foo #(  //comment\n"
-     "    parameter int a  = 2,\n"
-     "    parameter int aa = 22\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'parameter_declaration' and trailing comments
-     "module foo #(parameter int a = 2,//comment\n parameter int aa = 22);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    parameter int a  = 2,  //comment\n"
-     "    parameter int aa = 22\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'parameter_declaration' and pre-proc
-     "module foo #(parameter int a = 2,\n"
-     "`ifdef MACRO parameter int aa = 22, `endif\n"
-     "parameter int aaa = 222);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    parameter int a   = 2,\n"
-     "`ifdef MACRO\n"
-     "    parameter int aa  = 22,\n"
-     "`endif\n"
-     "    parameter int aaa = 222\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'parameter_declaration' and packed dimensions
-     "module foo #(parameter logic [3:0] a = 2, parameter logic [30:0] aa = "
-     "22);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    parameter logic [ 3:0] a  = 2,\n"
-     "    parameter logic [30:0] aa = 22\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'parameter_declaration' and unpacked
-     // dimensions
-     "module foo #(parameter logic a[3:0] = 2, parameter logic  aa [30:0] = "
-     "22);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    parameter logic a [ 3:0] = 2,\n"
-     "    parameter logic aa[30:0] = 22\n"
-     ");\n"
-     "endmodule\n"},
-
-    {// parameterized module with 'local_parameter_declaration'
-     "module foo #(localparam int a = 2, localparam int aa = 22);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    localparam int a  = 2,\n"
-     "    localparam int aa = 22\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'local_parameter_declaration' and comments
-     "module foo #(//comment\nlocalparam int a = 2, localparam int aa = 22);\n"
-     "endmodule\n",
-     "module foo #(  //comment\n"
-     "    localparam int a  = 2,\n"
-     "    localparam int aa = 22\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'local_parameter_declaration' and trailing
-     // comments
-     "module foo #(localparam int a = 2,//comment\n localparam int aa = 22);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    localparam int a  = 2,  //comment\n"
-     "    localparam int aa = 22\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'local_parameter_declaration' and pre-proc
-     "module foo #(localparam int a = 2,\n"
-     "`ifdef MACRO localparam int aa = 22, `endif\n"
-     "localparam int aaa = 222);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    localparam int a   = 2,\n"
-     "`ifdef MACRO\n"
-     "    localparam int aa  = 22,\n"
-     "`endif\n"
-     "    localparam int aaa = 222\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'local_parameter_declaration' and packed
-     // dimensions
-     "module foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa = "
-     "22);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    localparam logic [ 3:0] a  = 2,\n"
-     "    localparam logic [30:0] aa = 22\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'local_parameter_declaration' and unpacked
-     // dimensions
-     "module foo #(localparam logic a[3:0] = 2, localparam logic  aa [30:0] = "
-     "22);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    localparam logic a [ 3:0] = 2,\n"
-     "    localparam logic aa[30:0] = 22\n"
-     ");\n"
-     "endmodule\n"},
-
-    {// parameterized module with 'data_type list_of_param_assignments'
-     "module foo #( int a = 2,  real aa = 22, longint aaa = 222);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    int     a   = 2,\n"
-     "    real    aa  = 22,\n"
-     "    longint aaa = 222\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'data_type list_of_param_assignments' and
-     // comments
-     "module foo #(//comment\nint a = 2,  shortreal aa = 22, longint aaa = "
-     "222);\n"
-     "endmodule\n",
-     "module foo #(  //comment\n"
-     "    int       a   = 2,\n"
-     "    shortreal aa  = 22,\n"
-     "    longint   aaa = 222\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'data_type list_of_param_assignments' and
-     // trailing comments
-     "module foo #(int a = 2,  shortreal aa = 22,//comment\n longint aaa = "
-     "222);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    int       a   = 2,\n"
-     "    shortreal aa  = 22,  //comment\n"
-     "    longint   aaa = 222\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'data_type list_of_param_assignments' and
-     // pre-proc
-     "module foo #(int a = 2,\n"
-     "`ifdef MACRO shortreal aa = 22, `endif\n"
-     " longint aaa = 222);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    int       a   = 2,\n"
-     "`ifdef MACRO\n"
-     "    shortreal aa  = 22,\n"
-     "`endif\n"
-     "    longint   aaa = 222\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'data_type list_of_param_assignments' and
-     // packed dimensions
-     "module foo #(bit [1:0] a = 2,  reg [12:0] aa = 22, logic [123:0] aaa = "
-     "222);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    bit   [  1:0] a   = 2,\n"
-     "    reg   [ 12:0] aa  = 22,\n"
-     "    logic [123:0] aaa = 222\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'data_type list_of_param_assignments' and
-     // unpacked dimensions
-     "module foo #(bit  a[1:0] = 2,  reg  aa[12:0] = 22, logic aaa [123:0]  = "
-     "222);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    bit   a  [  1:0] = 2,\n"
-     "    reg   aa [ 12:0] = 22,\n"
-     "    logic aaa[123:0] = 222\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'type list_of_type_assignments'
-     "module foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    type T   = int,\n"
-     "    type TT  = bit,\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'type list_of_type_assignments' and comments
-     "module foo #(//comment\ntype T = int, type TT = bit, type TTT= C#(logic) "
-     ");\n"
-     "endmodule\n",
-     "module foo #(  //comment\n"
-     "    type T   = int,\n"
-     "    type TT  = bit,\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'data_type list_of_param_assignments' and
-     // trailing comments
-     "module foo #(type T = int, type TT = bit, //comment\n type TTT= "
-     "C#(logic) );\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    type T   = int,\n"
-     "    type TT  = bit,       //comment\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'data_type list_of_param_assignments' and
-     // pre-proc
-     "module foo #(type T = int,\n"
-     "`ifdef MACRO type TT = bit, `endif\n"
-     " type TTT= C#(logic));\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    type T   = int,\n"
-     "`ifdef MACRO\n"
-     "    type TT  = bit,\n"
-     "`endif\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'data_type list_of_param_assignments' and
-     // packed dimensions
-     "module foo #(type T = int [3:0], type TT = bit [250:0]);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    type T  = int [  3:0],\n"
-     "    type TT = bit [250:0]\n"
-     ");\n"
-     "endmodule\n"},
-    {"module foo #(type T = int, "
-     "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, "
-     "localparam AAAAA = 22222, localparam real AAAAAA = 222222"
-     ");\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "               type    T      = int,\n"
-     "                       A      = 2,\n"
-     "               int     AA     = 22,\n"
-     "    parameter          AAA    = 222,\n"
-     "    parameter  longint AAAA   = 2222,\n"
-     "    localparam         AAAAA  = 22222,\n"
-     "    localparam real    AAAAAA = 222222\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with built-in data type
-     "module foo #(int a = 2, real abc = 2234);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    int  a   = 2,\n"
-     "    real abc = 2234\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with type
-     "module foo #(type TYPE1 = int, type TYPE2 = boo);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    type TYPE1 = int,\n"
-     "    type TYPE2 = boo\n"
-     ");\n"
-     "endmodule\n"},
-    {"module foo#(localparam type TYPE1 = int, type TYPE22 = bool, parameter   "
-     " type TYPE333 = real);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    localparam type TYPE1   = int,\n"
-     "               type TYPE22  = bool,\n"
-     "    parameter  type TYPE333 = real\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'data_type list_of_param_assignments' and 1D
-     // packed dimensions
-     "module foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    parameter type T  = int [  3:0],\n"
-     "              type TT = bit [123:0]\n"
-     ");\n"
-     "endmodule\n"},
-    {// parameterized module with 'data_type list_of_param_assignments' and 2D
-     // packed dimensions
-     "module foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    type T  = int [  3:0][123:0],\n"
-     "    type TT = bit [123:0][  1:0]\n"
-     ");\n"
-     "endmodule\n"},
-    {// parametrized module with user defined data types
-     "module foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    type T  = my_type1_t,\n"
-     "    type TT = my_pkg::my_type2_t\n"
-     ");\n"
-     "endmodule\n"},
-
-    {// parameterized class with 'list_of_param_assignments'
-     "class foo #(A = 2, AA = 22, AAA = 222);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    A   = 2,\n"
-     "    AA  = 22,\n"
-     "    AAA = 222\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'parameter_declaration'
-     "class foo #(parameter int a = 2, parameter int aa = 22);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    parameter int a  = 2,\n"
-     "    parameter int aa = 22\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'parameter_declaration' and comments
-     "class foo #(//comment\nparameter int a = 2, parameter int aa = 22);\n"
-     "endclass\n",
-     "class foo #(  //comment\n"
-     "    parameter int a  = 2,\n"
-     "    parameter int aa = 22\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'parameter_declaration' and trailing comments
-     "class foo #(parameter int a = 2,//comment\n parameter int aa = 22);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    parameter int a  = 2,  //comment\n"
-     "    parameter int aa = 22\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'parameter_declaration' and pre-proc
-     "class foo #(parameter int a = 2,\n"
-     "`ifdef MACRO parameter int aa = 22, `endif\n"
-     "parameter int aaa = 222);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    parameter int a   = 2,\n"
-     "`ifdef MACRO\n"
-     "    parameter int aa  = 22,\n"
-     "`endif\n"
-     "    parameter int aaa = 222\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'parameter_declaration' and packed dimensions
-     "class foo #(parameter logic [3:0] a = 2, parameter logic [30:0] aa = "
-     "22);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    parameter logic [ 3:0] a  = 2,\n"
-     "    parameter logic [30:0] aa = 22\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'parameter_declaration' and unpacked dimensions
-     "class foo #(parameter logic a[3:0] = 2, parameter logic  aa [30:0] = "
-     "22);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    parameter logic a [ 3:0] = 2,\n"
-     "    parameter logic aa[30:0] = 22\n"
-     ");\n"
-     "endclass\n"},
-
-    {// parameterized class with 'local_parameter_declaration'
-     "class foo #(localparam int a = 2, localparam int aa = 22);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    localparam int a  = 2,\n"
-     "    localparam int aa = 22\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'local_parameter_declaration' and comments
-     "class foo #(//comment\nlocalparam int a = 2, localparam int aa = 22);\n"
-     "endclass\n",
-     "class foo #(  //comment\n"
-     "    localparam int a  = 2,\n"
-     "    localparam int aa = 22\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'local_parameter_declaration' and trailing
-     // comments
-     "class foo #(localparam int a = 2,//comment\n localparam int aa = 22);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    localparam int a  = 2,  //comment\n"
-     "    localparam int aa = 22\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'local_parameter_declaration' and pre-proc
-     "class foo #(localparam int a = 2,\n"
-     "`ifdef MACRO localparam int aa = 22, `endif\n"
-     "localparam int aaa = 222);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    localparam int a   = 2,\n"
-     "`ifdef MACRO\n"
-     "    localparam int aa  = 22,\n"
-     "`endif\n"
-     "    localparam int aaa = 222\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'local_parameter_declaration' and packed
-     // dimensions
-     "class foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa = "
-     "22);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    localparam logic [ 3:0] a  = 2,\n"
-     "    localparam logic [30:0] aa = 22\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'local_parameter_declaration' and unpacked
-     // dimensions
-     "class foo #(localparam logic a[3:0] = 2, localparam logic  aa [30:0] = "
-     "22);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    localparam logic a [ 3:0] = 2,\n"
-     "    localparam logic aa[30:0] = 22\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'data_type list_of_param_assignments'
-     "class foo #( int a = 2,  real aa = 22, longint aaa = 222);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    int     a   = 2,\n"
-     "    real    aa  = 22,\n"
-     "    longint aaa = 222\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'data_type list_of_param_assignments' and
-     // comments
-     "class foo #(//comment\nint a = 2,  shortreal aa = 22, longint aaa = "
-     "222);\n"
-     "endclass\n",
-     "class foo #(  //comment\n"
-     "    int       a   = 2,\n"
-     "    shortreal aa  = 22,\n"
-     "    longint   aaa = 222\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'data_type list_of_param_assignments' and
-     // trailing comments
-     "class foo #(int a = 2,  shortreal aa = 22,//comment\n longint aaa = "
-     "222);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    int       a   = 2,\n"
-     "    shortreal aa  = 22,  //comment\n"
-     "    longint   aaa = 222\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'data_type list_of_param_assignments' and
-     // pre-proc
-     "class foo #(int a = 2,\n"
-     "`ifdef MACRO shortreal aa = 22, `endif\n"
-     " longint aaa = 222);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    int       a   = 2,\n"
-     "`ifdef MACRO\n"
-     "    shortreal aa  = 22,\n"
-     "`endif\n"
-     "    longint   aaa = 222\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'data_type list_of_param_assignments' and
-     // packed dimensions
-     "class foo #(bit [1:0] a = 2,  reg [12:0] aa = 22, logic [123:0] aaa = "
-     "222);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    bit   [  1:0] a   = 2,\n"
-     "    reg   [ 12:0] aa  = 22,\n"
-     "    logic [123:0] aaa = 222\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'data_type list_of_param_assignments' and
-     // unpacked dimensions
-     "class foo #(bit  a[1:0] = 2,  reg  aa[12:0] = 22, logic aaa [123:0]  = "
-     "222);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    bit   a  [  1:0] = 2,\n"
-     "    reg   aa [ 12:0] = 22,\n"
-     "    logic aaa[123:0] = 222\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'type list_of_type_assignments'
-     "class foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    type T   = int,\n"
-     "    type TT  = bit,\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'type list_of_type_assignments' and comments
-     "class foo #(//comment\ntype T = int, type TT = bit, type TTT= C#(logic) "
-     ");\n"
-     "endclass\n",
-     "class foo #(  //comment\n"
-     "    type T   = int,\n"
-     "    type TT  = bit,\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'data_type list_of_param_assignments' and
-     // trailing comments
-     "class foo #(type T = int, type TT = bit, //comment\n type TTT= C#(logic) "
-     ");\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    type T   = int,\n"
-     "    type TT  = bit,       //comment\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'data_type list_of_param_assignments' and
-     // pre-proc
-     "class foo #(type T = int,\n"
-     "`ifdef MACRO type TT = bit, `endif\n"
-     " type TTT= C#(logic));\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    type T   = int,\n"
-     "`ifdef MACRO\n"
-     "    type TT  = bit,\n"
-     "`endif\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'data_type list_of_param_assignments' and
-     // packed dimensions
-     "class foo #(type T = int [3:0], type TT = bit [250:0]);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    type T  = int [  3:0],\n"
-     "    type TT = bit [250:0]\n"
-     ");\n"
-     "endclass\n"},
-    {"class foo #(type T = int, "
-     "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, "
-     "localparam AAAAA = 22222, localparam real AAAAAA = 222222"
-     ");\n"
-     "endclass\n",
-     "class foo #(\n"
-     "               type    T      = int,\n"
-     "                       A      = 2,\n"
-     "               int     AA     = 22,\n"
-     "    parameter          AAA    = 222,\n"
-     "    parameter  longint AAAA   = 2222,\n"
-     "    localparam         AAAAA  = 22222,\n"
-     "    localparam real    AAAAAA = 222222\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with built-in data type
-     "class foo #(int a = 2, real abc = 2234);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    int  a   = 2,\n"
-     "    real abc = 2234\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with type
-     "class foo #(type TYPE1 = int, type TYPE2 = boo);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    type TYPE1 = int,\n"
-     "    type TYPE2 = boo\n"
-     ");\n"
-     "endclass\n"},
-    {"class foo#(localparam type TYPE1 = int, type TYPE22 = bool, parameter    "
-     "type TYPE333 = real);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    localparam type TYPE1   = int,\n"
-     "               type TYPE22  = bool,\n"
-     "    parameter  type TYPE333 = real\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'data_type list_of_param_assignments' and 1D
-     // packed dimensions
-     "class foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    parameter type T  = int [  3:0],\n"
-     "              type TT = bit [123:0]\n"
-     ");\n"
-     "endclass\n"},
-    {// parameterized class with 'data_type list_of_param_assignments' and 2D
-     // packed dimensions
-     "class foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    type T  = int [  3:0][123:0],\n"
-     "    type TT = bit [123:0][  1:0]\n"
-     ");\n"
-     "endclass\n"},
-    {// parametrized class with user defined data types
-     "class foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n"
-     "endclass\n",
-     "class foo #(\n"
-     "    type T  = my_type1_t,\n"
-     "    type TT = my_pkg::my_type2_t\n"
-     ");\n"
-     "endclass\n"},
-
-    {// parameterized interface with 'local_parameter_declaration'
-     "interface foo #(localparam int a = 2, localparam int aa = 22);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    localparam int a  = 2,\n"
-     "    localparam int aa = 22\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'local_parameter_declaration' and comments
-     "interface foo #(//comment\nlocalparam int a = 2, localparam int aa = "
-     "22);\n"
-     "endinterface\n",
-     "interface foo #(  //comment\n"
-     "    localparam int a  = 2,\n"
-     "    localparam int aa = 22\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'local_parameter_declaration' and trailing
-     // comments
-     "interface foo #(localparam int a = 2,//comment\n localparam int aa = "
-     "22);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    localparam int a  = 2,  //comment\n"
-     "    localparam int aa = 22\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'local_parameter_declaration' and pre-proc
-     "interface foo #(localparam int a = 2,\n"
-     "`ifdef MACRO localparam int aa = 22, `endif\n"
-     "localparam int aaa = 222);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    localparam int a   = 2,\n"
-     "`ifdef MACRO\n"
-     "    localparam int aa  = 22,\n"
-     "`endif\n"
-     "    localparam int aaa = 222\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'local_parameter_declaration' and packed
-     // dimensions
-     "interface foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa "
-     "= 22);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    localparam logic [ 3:0] a  = 2,\n"
-     "    localparam logic [30:0] aa = 22\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'local_parameter_declaration' and unpacked
-     // dimensions
-     "interface foo #(localparam logic a[3:0] = 2, localparam logic  aa [30:0] "
-     "= 22);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    localparam logic a [ 3:0] = 2,\n"
-     "    localparam logic aa[30:0] = 22\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'data_type list_of_param_assignments'
-     "interface foo #( int a = 2,  real aa = 22, longint aaa = 222);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    int     a   = 2,\n"
-     "    real    aa  = 22,\n"
-     "    longint aaa = 222\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'data_type list_of_param_assignments' and
-     // comments
-     "interface foo #(//comment\nint a = 2,  shortreal aa = 22, longint aaa = "
-     "222);\n"
-     "endinterface\n",
-     "interface foo #(  //comment\n"
-     "    int       a   = 2,\n"
-     "    shortreal aa  = 22,\n"
-     "    longint   aaa = 222\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'data_type list_of_param_assignments' and
-     // trailing comments
-     "interface foo #(int a = 2,  shortreal aa = 22,//comment\n longint aaa = "
-     "222);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    int       a   = 2,\n"
-     "    shortreal aa  = 22,  //comment\n"
-     "    longint   aaa = 222\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'data_type list_of_param_assignments' and
-     // pre-proc
-     "interface foo #(int a = 2,\n"
-     "`ifdef MACRO shortreal aa = 22, `endif\n"
-     " longint aaa = 222);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    int       a   = 2,\n"
-     "`ifdef MACRO\n"
-     "    shortreal aa  = 22,\n"
-     "`endif\n"
-     "    longint   aaa = 222\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'data_type list_of_param_assignments' and
-     // packed dimensions
-     "interface foo #(bit [1:0] a = 2,  reg [12:0] aa = 22, logic [123:0] aaa "
-     "= 222);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    bit   [  1:0] a   = 2,\n"
-     "    reg   [ 12:0] aa  = 22,\n"
-     "    logic [123:0] aaa = 222\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'data_type list_of_param_assignments' and
-     // unpacked dimensions
-     "interface foo #(bit  a[1:0] = 2,  reg  aa[12:0] = 22, logic aaa [123:0]  "
-     "= 222);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    bit   a  [  1:0] = 2,\n"
-     "    reg   aa [ 12:0] = 22,\n"
-     "    logic aaa[123:0] = 222\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'type list_of_type_assignments'
-     "interface foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    type T   = int,\n"
-     "    type TT  = bit,\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'type list_of_type_assignments' and
-     // comments
-     "interface foo #(//comment\ntype T = int, type TT = bit, type TTT= "
-     "C#(logic) );\n"
-     "endinterface\n",
-     "interface foo #(  //comment\n"
-     "    type T   = int,\n"
-     "    type TT  = bit,\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'data_type list_of_param_assignments' and
-     // trailing comments
-     "interface foo #(type T = int, type TT = bit, //comment\n type TTT= "
-     "C#(logic) );\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    type T   = int,\n"
-     "    type TT  = bit,       //comment\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'data_type list_of_param_assignments' and
-     // pre-proc
-     "interface foo #(type T = int,\n"
-     "`ifdef MACRO type TT = bit, `endif\n"
-     " type TTT= C#(logic));\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    type T   = int,\n"
-     "`ifdef MACRO\n"
-     "    type TT  = bit,\n"
-     "`endif\n"
-     "    type TTT = C#(logic)\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'data_type list_of_param_assignments' and
-     // packed dimensions
-     "interface foo #(type T = int [3:0], type TT = bit [250:0]);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    type T  = int [  3:0],\n"
-     "    type TT = bit [250:0]\n"
-     ");\n"
-     "endinterface\n"},
-    {"interface foo #(type T = int, "
-     "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, "
-     "localparam AAAAA = 22222, localparam real AAAAAA = 222222"
-     ");\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "               type    T      = int,\n"
-     "                       A      = 2,\n"
-     "               int     AA     = 22,\n"
-     "    parameter          AAA    = 222,\n"
-     "    parameter  longint AAAA   = 2222,\n"
-     "    localparam         AAAAA  = 22222,\n"
-     "    localparam real    AAAAAA = 222222\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with built-in data type
-     "interface foo #(int a = 2, real abc = 2234);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    int  a   = 2,\n"
-     "    real abc = 2234\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with type
-     "interface foo #(type TYPE1 = int, type TYPE2 = boo);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    type TYPE1 = int,\n"
-     "    type TYPE2 = boo\n"
-     ");\n"
-     "endinterface\n"},
-    {"interface foo#(localparam type TYPE1 = int, type TYPE22 = bool, "
-     "parameter    type TYPE333 = real);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    localparam type TYPE1   = int,\n"
-     "               type TYPE22  = bool,\n"
-     "    parameter  type TYPE333 = real\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'data_type list_of_param_assignments' and
-     // 1D packed dimensions
-     "interface foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    parameter type T  = int [  3:0],\n"
-     "              type TT = bit [123:0]\n"
-     ");\n"
-     "endinterface\n"},
-    {// parameterized interface with 'data_type list_of_param_assignments' and
-     // 2D packed dimensions
-     "interface foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    type T  = int [  3:0][123:0],\n"
-     "    type TT = bit [123:0][  1:0]\n"
-     ");\n"
-     "endinterface\n"},
-    {// parametrized interface with user defined data types
-     "interface foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n"
-     "endinterface\n",
-     "interface foo #(\n"
-     "    type T  = my_type1_t,\n"
-     "    type TT = my_pkg::my_type2_t\n"
-     ");\n"
-     "endinterface\n"},
-    {// wildcard import package at module header
-     "module foo import bar::*; (baz); endmodule\n",
-     "module foo\n"
-     "  import bar::*;\n"
-     "(\n"
-     "    baz\n"
-     ");\n"
-     "endmodule\n"},
-    {// import package at module header
-     "module foo import bar::baz; (qux); endmodule\n",
-     "module foo\n"
-     "  import bar::baz;\n"
-     "(\n"
-     "    qux\n"
-     ");\n"
-     "endmodule\n"},
-    {// wildcard import multiple packages at module header
-     "module foo import bar::*,baz::*; (qux); endmodule\n",
-     "module foo\n"
-     "  import bar::*, baz::*;\n"
-     "(\n"
-     "    qux\n"
-     ");\n"
-     "endmodule\n"},
-    {// separate package import declarations in module header
-     "module foo import bar::*,baz::*; import q_pkg::qux; (qux); endmodule\n",
-     "module foo\n"
-     "  import bar::*, baz::*;\n"
-     "  import q_pkg::qux;\n"
-     "(\n"
-     "    qux\n"
-     ");\n"
-     "endmodule\n"},
-    {// import package at module header
-     "module foo import bar::baz; #(int p = 3)(qux); endmodule\n",
-     "module foo\n"
-     "  import bar::baz;\n"
-     "#(\n"
-     "    int p = 3\n"
-     ") (\n"
-     "    qux\n"
-     ");\n"
-     "endmodule\n"},
-    // Space between return keyword and return value
-    {"function int foo(logic [31:0] data); return{<<8{data}}; endfunction",
-     "function int foo(logic [31:0] data);\n"
-     "  return {<<8{data}};\n"
-     "endfunction\n"},
-    {"function int f;return(1);endfunction",
-     "function int f;\n"
-     "  return (1);\n"
-     "endfunction\n"},
-    {"function int f;return-1;endfunction",
-     "function int f;\n"
-     "  return -1;\n"
-     "endfunction\n"},
-    {"function int f ;return    ! x\n;endfunction",
-     "function int f;\n"
-     "  return !x;\n"
-     "endfunction\n"},
-    {"function int f ;return    ~ x\n;endfunction",
-     "function int f;\n"
-     "  return ~x;\n"
-     "endfunction\n"},
-    {"function int f ;return    $x\n;endfunction",
-     "function int f;\n"
-     "  return $x;\n"
-     "endfunction\n"},
-    // String initializers
-    {"string a[] = {\n\"a\"\n};\n", "string a[] = {\"a\"};\n"},
-    {"string abc[] = {\n\"a\",\n\"b\",\n\"c\"\n};\n",
-     "string abc[] = {\"a\", \"b\", \"c\"};\n"},
-    {"string abc[] = {\n"
-     "\"a\",//\n"
-     "\"b\", \"c\"\n"
-     "};\n",
-     "string abc[] = {\"a\",  //\n"
-     "                \"b\",\n"
-     "                \"c\"};\n"},
-    {"string abc[] = {//\n"
-     "\"a\", \"b\", \"c\""
-     "};\n",
-     "string abc[] = {  //\n"
-     "  \"a\",\n"
-     "  \"b\",\n"
-     "  \"c\"\n"
-     "};\n"},
-    {"string abc[] = {\n"
-     "\"a\", \"b\", \"c\"//\n"
-     "};\n",
-     "string abc[] = {\"a\",\n"
-     "                \"b\",\n"
-     "                \"c\"  //\n"
-     "                };\n"},
-    {"string abc[] = {//\n"
-     "\"a\",//\n"
-     "\"b\", \"c\"//\n"
-     "};\n",
-     "string abc[] = {  //\n"
-     "  \"a\",  //\n"
-     "  \"b\",\n"
-     "  \"c\"  //\n"
-     "};\n"},
-    {"string abc[] = {\n"
-     "\"a\",\n"
-     "// comment\n"
-     "// comment\n"
-     "\"b\",\n"
-     "\"c\"\n"
-     "};\n",
-     "string abc[] = {\"a\",\n"
-     "                // comment\n"
-     "                // comment\n"
-     "                \"b\",\n"
-     "                \"c\"};\n"},
-    {"string numbers[] = {\"one\", \"two\", \"three\", \"four\"};\n",
-     "string numbers[] = {\"one\",\n"
-     "                    \"two\",\n"
-     "                    \"three\",\n"
-     "                    \"four\"};\n"},
-    {"string numbers[] = {\"one\", \"two\", THREE, \"four\"};\n",
-     "string numbers[] = {\n"
-     "  \"one\", \"two\", THREE, \"four\"\n"
-     "};\n"},
-    {"string numbers[] = {\"one\", {\"two\", \"three\"}, \"four\"};\n",
-     "string numbers[] = {\n"
-     "  \"one\", {\"two\", \"three\"}, \"four\"\n"
-     "};\n"},
-    {"string numbers[] = {\"one\", {\"two\", //\n"
-     "\"three\"}, \"four\"};\n",
-     "string numbers[] = {\n"
-     "  \"one\",\n"
-     "  {\n"
-     "    \"two\",  //\n"
-     "    \"three\"\n"
-     "  },\n"
-     "  \"four\"\n"
-     "};\n"},
-    {"string years[] = {\"two_thousand_nineteen\", \"two_thousand_twenty\",\n"
-     "\"two_thousand_twenty_one\"};\n",
-     // line with 3rd string would exceed column limit in unwrapped style
-     "string years[] = {\n"
-     "  \"two_thousand_nineteen\",\n"
-     "  \"two_thousand_twenty\",\n"
-     "  \"two_thousand_twenty_one\"\n"
-     "};\n"},
-    {"class class_name;\n"
-     "var_type var_name = new(\"the_string\");\n"
-     "endclass\n",
-     "class class_name;\n"
-     "  var_type var_name = new(\"the_string\");\n"
-     "endclass\n"},
-
-    //{   // parameterized class with 'parameter_declaration' and MACRO
-    //    "class foo #(parameter int a = 2,\n"
-    //    "parameter int aaa = `MACRO);\n"
-    //    "endclass\n",
-    //    "class foo #(\n"
-    //    "    parameter int a   = 2,\n"
-    //    "    parameter int aaa = `MACRO\n"
-    //    ");\n"
-    //    "endclass\n"
-    //},
-    // Struct/Union alignment
-    {"typedef struct {\n"
-     "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n"
-     "} type_t;",
-     "typedef struct {\n"
-     "  bit [3:0]           first;\n"
-     "  bit [31:0]          second;\n"
-     "  generic_type_name_t third;\n"
-     "} type_t;\n"},
-    {"typedef union soft packed {\n"
-     "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n"
-     "} type_t;",
-     "typedef union soft packed {\n"
-     "  bit [3:0]           first;\n"
-     "  bit [31:0]          second;\n"
-     "  generic_type_name_t third;\n"
-     "} type_t;\n"},
-    {"typedef union soft {\n"
-     "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n"
-     "} type_t;",
-     "typedef union soft {\n"
-     "  bit [3:0]           first;\n"
-     "  bit [31:0]          second;\n"
-     "  generic_type_name_t third;\n"
-     "} type_t;\n"},
-    {"typedef struct {\n"
-     "// comment\n"
-     "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n"
-     "} type_t;",
-     "typedef struct {\n"
-     "  // comment\n"
-     "  bit [3:0]           first;\n"
-     "  bit [31:0]          second;\n"
-     "  generic_type_name_t third;\n"
-     "} type_t;\n"},
-    {"typedef struct {\n"
-     "// comment 0\n"
-     "bit [31:0] first; // a\n"
-     "bit [31:0] second; // b\n"
-     "bit third; // c\n"
-     "uint fourth; // d\n"
-     "\n"
-     "// comment 1\n"
-     "int fifth;\n"
-     "// comment 2.1\n"
-     "// comment 2.2\n"
-     "uint sixth;\n"
-     "} timing_cfg_t;",
-     "typedef struct {\n"
-     "  // comment 0\n"
-     "  bit [31:0] first;   // a\n"
-     "  bit [31:0] second;  // b\n"
-     "  bit        third;   // c\n"
-     "  uint       fourth;  // d\n"
-     "\n"
-     "  // comment 1\n"
-     "  int  fifth;\n"
-     "  // comment 2.1\n"
-     "  // comment 2.2\n"
-     "  uint sixth;\n"
-     "} timing_cfg_t;\n"},
-    {"typedef struct {\n"
-     "// comment\n"
-     "rand int r;\n"
-     "int a;\n"
-     "int aa = 0;\n"
-     "int aaa = 1; // comment\n"
-     "foo#(bar) z;\n"
-     "int [x:y] zz; // comment\n"
-     "int zzz[a:b];\n"
-     "} type_t;",
-     "typedef struct {\n"
-     "  // comment\n"
-     "  rand int   r;\n"
-     "  int        a;\n"
-     "  int        aa        = 0;\n"
-     "  int        aaa       = 1;  // comment\n"
-     "  foo #(bar) z;\n"
-     "  int [x:y]  zz;             // comment\n"
-     "  int        zzz[a:b];\n"
-     "} type_t;\n"},
-    {"typedef struct packed {\n"
-     "struct packed { bit q; logic qq; logic qqq; } a_few_qs;\n"
-     "struct packed {\n"
-     "logic [1:0]  q;\n"
-     "} one_q;\n"
-     "int q;\n"
-     "uint qq;\n"
-     "} nested_qs_t;",
-     "typedef struct packed {\n"
-     "  struct packed {\n"
-     "    bit   q;\n"
-     "    logic qq;\n"
-     "    logic qqq;\n"
-     "  } a_few_qs;\n"
-     "  struct packed {logic [1:0] q;} one_q;\n"
-     "  int  q;\n"
-     "  uint qq;\n"
-     "} nested_qs_t;\n"},
-    {"typedef struct packed {\n"
-     "struct packed { bit q; logic qq; logic qqq; } a_few_qs;\n"
-     "struct packed {\n"
-     "// comment\n"
-     "logic [1:0]  q;\n"
-     "} one_q;\n"
-     "int q;\n"
-     "uint qq;\n"
-     "} nested_qs_t;",
-     "typedef struct packed {\n"
-     "  struct packed {\n"
-     "    bit   q;\n"
-     "    logic qq;\n"
-     "    logic qqq;\n"
-     "  } a_few_qs;\n"
-     "  struct packed {\n"
-     "    // comment\n"
-     "    logic [1:0] q;\n"
-     "  } one_q;\n"
-     "  int  q;\n"
-     "  uint qq;\n"
-     "} nested_qs_t;\n"},
-    {"typedef struct {bit [3:0] first;\n"
-     "`ifdef MACRO\n"
-     "bit [31:0] second; generic_type_name_t third;\n"
-     "`endif\n"
-     "} type_t;\n",
-     "typedef struct {\n"
-     "  bit [3:0]           first;\n"
-     "`ifdef MACRO\n"
-     "  bit [31:0]          second;\n"
-     "  generic_type_name_t third;\n"
-     "`endif\n"
-     "} type_t;\n"},
-    {"typedef struct {\n"
-     "bit [3:0] first // c\n"
-     "; bit [31:0] second"
-     "// c\n"
-     "; generic_type_name_t third // c\n"
-     ";} type_t;\n",
-     "typedef struct {\n"
-     "  bit [3:0]           first  // c\n"
-     ";\n"
-     "  bit [31:0]          second  // c\n"
-     ";\n"
-     "  generic_type_name_t third  // c\n"
-     ";\n"
-     "} type_t;\n"},
-    {"struct {logic test1; // c\n"
-     "logic test2;} test3;\n",
-     "struct {\n"
-     "  logic test1;  // c\n"
-     "  logic test2;\n"
-     "} test3;\n"},
-    {"struct {\n"
-     "  /* t */ logic test1; /* t */\n"
-     "/* t */ logic test2; }test3;\n",
-     "struct {\n"
-     "  /* t */ logic test1;  /* t */\n"
-     "  /* t */ logic test2;\n"
-     "} test3;\n"},
-    // Continuation comment alignment
-    {"`define BAR 1 // A\n"
-     "module foo(); // B\n"
-     "wire baz;     // C\n"
-     "endmodule:foo // D\n",
-     "`define BAR 1 // A\n"
-     "module foo ();  // B\n"
-     "  wire baz;  // C\n"
-     "endmodule : foo  // D\n"},
-    {"`define BAR 1 // A\n"
-     "module foo(); // B\n"
-     "              // B.1\n"
-     "              // B.2\n"
-     "wire baz;     // C\n"
-     "              // C.1\n"
-     "              // C.2\n"
-     "endmodule:foo // D\n"
-     "              // D.1\n"
-     "              // D.2\n",
-     "`define BAR 1 // A\n"
-     "module foo ();  // B\n"
-     "                // B.1\n"
-     "                // B.2\n"
-     "  wire baz;  // C\n"
-     "             // C.1\n"
-     "             // C.2\n"
-     "endmodule : foo  // D\n"
-     "                 // D.1\n"
-     "                 // D.2\n"},
-    {"// W\n"
-     "`define BAR 1 // A\n"
-     "   // X\n"
-     "module foo(); // B\n"
-     "              // B.1\n"
-     "              // B.2\n"
-     " // Y\n"
-     "wire baz;     // C\n"
-     "              // C.1\n"
-     "              // C.2\n"
-     "    // Z\n"
-     "endmodule:foo // D\n"
-     "              // D.1\n"
-     "              // D.2\n",
-     "// W\n"
-     "`define BAR 1 // A\n"
-     "// X\n"
-     "module foo ();  // B\n"
-     "                // B.1\n"
-     "                // B.2\n"
-     "  // Y\n"
-     "  wire baz;  // C\n"
-     "             // C.1\n"
-     "             // C.2\n"
-     "  // Z\n"
-     "endmodule : foo  // D\n"
-     "                 // D.1\n"
-     "                 // D.2\n"},
-    {"module foo( // A\n"
-     "            // A.1\n"
-     "// X\n"
-     "input wire i1 [a:b], // B\n"
-     "                     // B.1\n"
-     "input [c:d] i2, // C\n"
-     "                // C.1\n"
-     "\n"
-     "// Y\n"
-     "output reg o1 // D\n"
-     "              // D.1\n"
-     ");endmodule:foo\n",
-     "module foo (  // A\n"
-     "              // A.1\n"
-     "    // X\n"
-     "    input wire       i1[a:b],  // B\n"
-     "                               // B.1\n"
-     "    input      [c:d] i2,       // C\n"
-     "                               // C.1\n"
-     "\n"
-     "    // Y\n"
-     "    output reg o1  // D\n"
-     "                   // D.1\n"
-     ");\n"
-     "endmodule : foo\n"},
-    // user defined type alignment
-    {
-        "module foo();\n"
-        "  logic [5:0][5:0] net_c;\n"
-        " messy_type_name [1:0] net_e;\n"
-        "endmodule\n",
-        "module foo ();\n"
-        "  logic           [5:0][5:0] net_c;\n"
-        "  messy_type_name [1:0]      net_e;\n"
-        "endmodule\n",
-    },
-    // Continuation comment's original starting column is allowed to differ from
-    // starting comment's original starting column at most by 1.
-    // Starting column of comments B and C will change after formatting.
-    // TODO: refine the column alignment depending on current vs previous line.
-    // https://github.com/chipsalliance/verible/pull/858#discussion_r672844015
-    {"module foo ();  // A\n"     // Starting comment; already on correct column
-     "                 // A.1\n"  // A's column + 1
-     "               // A.2\n"    // A's column - 1
-     "wire baz;      // B\n"      // Starting comment; will be moved left
-     "              // B.1\n"     // B's column - 1
-     "                // B.2\n"   // B's column + 1
-     "               // B.3\n"    // B's column
-     "endmodule:foo // C\n"       // Starting comment; will be moved right
-     "               // C.1\n"    // C's column + 1
-     "             // C.2\n",     // C's column - 1
-     "module foo ();  // A\n"
-     "                // A.1\n"
-     "                // A.2\n"
-     "  wire baz;  // B\n"
-     "             // B.1\n"
-     "             // B.2\n"
-     "             // B.3\n"
-     "endmodule : foo  // C\n"
-     "                 // C.1\n"
-     "                 // C.2\n"},
-    {"module foo\n"
-     "#(\n"
-     "  parameter type baz_t = struct packed { `BAZ(); }\n"
-     ")\n"
-     "();\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    parameter type\n"
-     "        baz_t = struct packed {\n"
-     "      `BAZ();\n"
-     "    }\n"
-     ") ();\n"
-     "endmodule\n"},
-    // The same as the previous test case, but without a semicolon at the macro
-    // call
-    {"module foo\n"
-     "#(\n"
-     "  parameter type baz_t = struct packed { `BAZ() }\n"
-     ")\n"
-     "();\n"
-     "endmodule\n",
-     "module foo #(\n"
-     "    parameter type\n"
-     "        baz_t = struct packed {\n"
-     "      `BAZ()\n"
-     "    }\n"
-     ") ();\n"
-     "endmodule\n"},
-    // Check that comments with too large starting column difference are not
-    // aligned as continuation comments.
-    // Check that starting comments are not linked with a comment in
-    // comment-only line above them, even when the starting column is the same.
-    // All comments in this test case are aligned independently, i.e. none are
-    // "continuation comments".
-    {"                // comment1\n"  // A's column, but is above it
-     "module foo ();  // A\n"
-     "                  // comment2\n"  // A's column + 2
-     "              // comment3\n"      // A's column - 2
-     "wire baz;     // B\n"
-     "            // comment4\n"      // B's column - 2
-     "                // comment5\n"  // B's column + 2
-     "              // comment6\n"    // B's column, but not directly under B
-     "endmodule:foo // C\n"
-     "                // comment7\n"  // C's column + 2
-     "              // comment8\n",   // C's column, but not directly under B
-     "// comment1\n"
-     "module foo ();  // A\n"
-     "  // comment2\n"
-     "  // comment3\n"
-     "  wire baz;  // B\n"
-     "  // comment4\n"
-     "  // comment5\n"
-     "  // comment6\n"
-     "endmodule : foo  // C\n"
-     "// comment7\n"
-     "// comment8\n"},
-    // Continuation comment alignment when a line with the starting comment is
-    // wrapped.
-    {"module foo(output logic very_very_very_very_long_name // A\n"
-     "                                                      // A.1\n"
-     "); endmodule\n",
-     "module foo (\n"
-     "    output logic\n"
-     "        very_very_very_very_long_name  // A\n"
-     "                                       // A.1\n"
-     ");\n"
-     "endmodule\n"},
-
-    // Attachment of ',' to elements in enum list (with and without comments)
-    {"typedef enum {\n"
-     "  first , // c1\n"
-     "  second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  first,  // c1\n"
-     "  second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first ,\n"
-     "  // c1\n"
-     "  second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  first,\n"
-     "  // c1\n"
-     "  second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first // c1\n"
-     "  , second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "    first   // c1\n"
-     "  , second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first\n"
-     "  // c1\n"
-     "  , second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "    first\n"
-     "  // c1\n"
-     "  , second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first // c1\n"
-     "  , // c2\n"
-     "  second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  first   // c1\n"
-     "  ,  // c2\n"
-     "  second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first\n"
-     "  // c1\n"
-     "  ,\n"
-     "  // c2\n"
-     "  second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  first\n"
-     "  // c1\n"
-     "  ,  // c2\n"
-     "  second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first\n"
-     "  // c1\n"
-     "  , // c2\n"
-     "  // c3\n"
-     "  second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  first\n"
-     "  // c1\n"
-     "  ,  // c2\n"
-     "  // c3\n"
-     "  second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  // c1\n"
-     "  first\n"
-     "  // c2\n"
-     "  , // c3\n"
-     "  // c4\n"
-     "  second\n"
-     "  // c5\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  // c1\n"
-     "  first\n"
-     "  // c2\n"
-     "  ,  // c3\n"
-     "  // c4\n"
-     "  second\n"
-     "  // c5\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  // c1\n"
-     "  // c1+\n"
-     "  first // c2\n"
-     "        // c2+\n"
-     "  , // c3\n"
-     "    // c3+\n"
-     "  // c4\n"
-     "  // c4+\n"
-     "  second // c5\n"
-     "         // c5+\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  // c1\n"
-     "  // c1+\n"
-     "  first   // c2\n"
-     "          // c2+\n"
-     "  ,  // c3\n"
-     "     // c3+\n"
-     "  // c4\n"
-     "  // c4+\n"
-     "  second  // c5\n"
-     "          // c5+\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first , /* c1 */\n"
-     "  second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  first,  /* c1 */\n"
-     "  second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first ,\n"
-     "  /* c1 */\n"
-     "  second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  first,\n"
-     "  /* c1 */\n"
-     "  second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first /* c1 */\n"
-     "  , second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "    first   /* c1 */\n"
-     "  , second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first\n"
-     "  /* c1 */\n"
-     "  , second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "    first\n"
-     "  /* c1 */\n"
-     "  , second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first /* c1 */\n"
-     "  , /* c2 */\n"
-     "  second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  first   /* c1 */\n"
-     "  ,  /* c2 */\n"
-     "  second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  first\n"
-     "  /* c1 */\n"
-     "  ,\n"
-     "  /* c2 */\n"
-     "  second\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  first\n"
-     "  /* c1 */\n"
-     "  ,\n"
-     "  /* c2 */\n"
-     "  second\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  /* c1 */\n"
-     "  first\n"
-     "  /* c2 */\n"
-     "  , /* c3 */\n"
-     "  /* c4 */\n"
-     "  second\n"
-     "  /* c5 */\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  /* c1 */\n"
-     "  first\n"
-     "  /* c2 */\n"
-     "  ,  /* c3 */\n"
-     "  /* c4 */\n"
-     "  second\n"
-     "  /* c5 */\n"
-     "} e;\n"},
-    {"typedef enum {\n"
-     "  /* c1  */\n"
-     "  /* c1+ */\n"
-     "  first /* c2  */\n"
-     "        /* c2+ */\n"
-     "  , /* c3  */\n"
-     "    /* c3+ */\n"
-     "  /* c4  */\n"
-     "  /* c4+ */\n"
-     "  second /* c5  */\n"
-     "         /* c5+ */\n"
-     "} e;\n",
-     "typedef enum {\n"
-     "  /* c1  */\n"
-     "  /* c1+ */\n"
-     "  first   /* c2  */\n"
-     "  /* c2+ */\n"
-     "  ,  /* c3  */\n"
-     "  /* c3+ */\n"
-     "  /* c4  */\n"
-     "  /* c4+ */\n"
-     "  second  /* c5  */\n"
-     "  /* c5+ */\n"
-     "} e;\n"},
-    {"module m;\n"
-     "typedef enum {\n"
-     "  first,\n"
-     "  second\n"
-     "} // c\n"
-     "e;\n"
-     "endmodule\n",
-     "module m;\n"
-     "  typedef enum {\n"
-     "    first,\n"
-     "    second\n"
-     "  }  // c\n"
-     "  e;\n"
-     "endmodule\n"},
-    // Attachment of ';' preceded by EOL comment
-    {"module m;\n"
-     "typedef enum {\n"
-     "  first,\n"
-     "  second\n"
-     "} e // c\n"
-     ";\n"
-     "endmodule\n",
-     "module m;\n"
-     "  typedef enum {\n"
-     "    first,\n"
-     "    second\n"
-     "  } e  // c\n"
-     "  ;\n"
-     "endmodule\n"},
-    {"module m;\n"
-     "typedef enum {\n"
-     "  first,\n"
-     "  second\n"
-     "} // c1\n"
-     "e // c2\n"
-     ";\n"
-     "endmodule\n",
-     "module m;\n"
-     "  typedef enum {\n"
-     "    first,\n"
-     "    second\n"
-     "  }  // c1\n"
-     "  e  // c2\n"
-     "  ;\n"
-     "endmodule\n"},
-    {"assign foo = bar\n"
-     "// comment\n"
-     ";\n",
-     "assign foo = bar\n"
-     "    // comment\n"
-     "    ;\n"},
-    {"assign foo = bar // comment\n"
-     ";\n",
-     "assign foo = bar  // comment\n"
-     ";\n"},
-
-    // Attachment of ',' to elements in PortActualList (with and without
-    // comments)
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    .first(1) // c1\n"
-     "    ,\n"
-     "    .second(2) // c2\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "        .first (1)  // c1\n"
-     "      , .second(2)  // c2\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    .first(1) // c1\n"
-     "    , .second(2) // c2\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "        .first (1)  // c1\n"
-     "      , .second(2)  // c2\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    .first(1)\n"
-     "    // c1\n"
-     "    ,\n"
-     "    .second(2)\n"
-     "    // c2\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "        .first (1)\n"
-     "      // c1\n"
-     "      , .second(2)\n"
-     "      // c2\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    .first(1)\n"
-     "    // c1\n"
-     "    , .second(2)\n"
-     "    // c2\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "        .first (1)\n"
-     "      // c1\n"
-     "      , .second(2)\n"
-     "      // c2\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    .first(1)\n"
-     "    // c1\n"
-     "    , // c2\n"
-     "    .second(2)\n"
-     "    // c3\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "      .first (1)\n"
-     "      // c1\n"
-     "      ,  // c2\n"
-     "      .second(2)\n"
-     "      // c3\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    // c1\n"
-     "    // c1+\n"
-     "    .first(1) // c2\n"
-     "              // c2+\n"
-     "    , // c3\n"
-     "      // c3+\n"
-     "    .second(2) // c4\n"
-     "               // c4+\n"
-     "    // c5\n"
-     "    // c5+\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "      // c1\n"
-     "      // c1+\n"
-     "      .first (1)  // c2\n"
-     "                  // c2+\n"
-     "      ,  // c3\n"
-     "         // c3+\n"
-     "      .second(2)  // c4\n"
-     "                  // c4+\n"
-     "      // c5\n"
-     "      // c5+\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    .first(1) /* c1 */\n"
-     "    ,\n"
-     "    .second(2) /* c2 */\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "        .first (1)  /* c1 */\n"
-     "      , .second(2)  /* c2 */\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    /* c1 */ .first(1),\n"
-     "    /* c2 */ .second(2)\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "      /* c1 */.first (1),\n"
-     "      /* c2 */.second(2)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    .first(1) /* c1 */\n"
-     "    , .second(2) /* c2 */\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "        .first (1)  /* c1 */\n"
-     "      , .second(2)  /* c2 */\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    /* c1 */.first(1)\n"
-     "    /* c2 */, .second(2)\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "      /* c1 */  .first (1)\n"
-     "      /* c2 */, .second(2)\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    .first(1)\n"
-     "    /* c1 */\n"
-     "    ,\n"
-     "    .second(2)\n"
-     "    /* c2 */\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "        .first (1)\n"
-     "      /* c1 */\n"
-     "      , .second(2)\n"
-     "      /* c2 */\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    .first(1)\n"
-     "    /* c1 */\n"
-     "    , .second(2)\n"
-     "    /* c2 */\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "        .first (1)\n"
-     "      /* c1 */\n"
-     "      , .second(2)\n"
-     "      /* c2 */\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    .first(1)\n"
-     "    /* c1 */\n"
-     "    , /* c2 */\n"
-     "    .second(2)\n"
-     "    /* c3 */\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "      .first (1)\n"
-     "      /* c1 */\n"
-     "      ,  /* c2 */\n"
-     "      .second(2)\n"
-     "      /* c3 */\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    .first(1)\n"
-     "    /* c1 */\n"
-     "    , /* c2 */\n"
-     "    .second(2)\n"
-     "    /* c3 */\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "      .first (1)\n"
-     "      /* c1 */\n"
-     "      ,  /* c2 */\n"
-     "      .second(2)\n"
-     "      /* c3 */\n"
-     "  );\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar foobar(\n"
-     "    /* c1  */\n"
-     "    /* c1+ */\n"
-     "    .first(1) /* c2  */\n"
-     "              /* c2+ */\n"
-     "    , /* c3  */\n"
-     "      /* c3+ */\n"
-     "    .second(2) /* c4  */\n"
-     "               /* c4+ */\n"
-     "    /* c5  */\n"
-     "    /* c5+ */\n"
-     "  );\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar foobar (\n"
-     "      /* c1  */\n"
-     "      /* c1+ */\n"
-     "      .first (1)  /* c2  */\n"
-     "      /* c2+ */\n"
-     "      ,  /* c3  */\n"
-     "      /* c3+ */\n"
-     "      .second(2)  /* c4  */\n"
-     "      /* c4+ */\n"
-     "      /* c5  */\n"
-     "      /* c5+ */\n"
-     "  );\n"
-     "endmodule\n"},
-
-    // Attachment of ',' to elements in ActualNamedParameterList (with and
-    // without comments)
-    {"module foo;\n"
-     "  bar#(\n"
-     "    .first(1) // c1\n"
-     "    ,\n"
-     "    .second(2) // c2\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "        .first (1)  // c1\n"
-     "      , .second(2)  // c2\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    .first(1) // c1\n"
-     "    , .second(2) // c2\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "        .first (1)  // c1\n"
-     "      , .second(2)  // c2\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    .first(1)\n"
-     "    // c1\n"
-     "    ,\n"
-     "    .second(2)\n"
-     "    // c2\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "        .first (1)\n"
-     "      // c1\n"
-     "      , .second(2)\n"
-     "      // c2\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    .first(1)\n"
-     "    // c1\n"
-     "    , .second(2)\n"
-     "    // c2\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "        .first (1)\n"
-     "      // c1\n"
-     "      , .second(2)\n"
-     "      // c2\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    .first(1)\n"
-     "    // c1\n"
-     "    , // c2\n"
-     "    .second(2)\n"
-     "    // c3\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "      .first (1)\n"
-     "      // c1\n"
-     "      ,  // c2\n"
-     "      .second(2)\n"
-     "      // c3\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    // c1\n"
-     "    // c1+\n"
-     "    .first(1) // c2\n"
-     "              // c2+\n"
-     "    , // c3\n"
-     "      // c3+\n"
-     "    .second(2) // c4\n"
-     "               // c4+\n"
-     "    // c5\n"
-     "    // c5+\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "      // c1\n"
-     "      // c1+\n"
-     "      .first (1)  // c2\n"
-     "                  // c2+\n"
-     "      ,  // c3\n"
-     "         // c3+\n"
-     "      .second(2)  // c4\n"
-     "                  // c4+\n"
-     "      // c5\n"
-     "      // c5+\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    .first(1) /* c1 */\n"
-     "    ,\n"
-     "    .second(2) /* c2 */\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "        .first (1)  /* c1 */\n"
-     "      , .second(2)  /* c2 */\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    /* c1 */ .first(1),\n"
-     "    /* c2 */ .second(2)\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "      /* c1 */.first (1),\n"
-     "      /* c2 */.second(2)\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    .first(1) /* c1 */\n"
-     "    , .second(2) /* c2 */\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "        .first (1)  /* c1 */\n"
-     "      , .second(2)  /* c2 */\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    /* c1 */.first(1)\n"
-     "    /* c2 */, .second(2)\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "      /* c1 */  .first (1)\n"
-     "      /* c2 */, .second(2)\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    .first(1)\n"
-     "    /* c1 */\n"
-     "    ,\n"
-     "    .second(2)\n"
-     "    /* c2 */\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "        .first (1)\n"
-     "      /* c1 */\n"
-     "      , .second(2)\n"
-     "      /* c2 */\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    .first(1)\n"
-     "    /* c1 */\n"
-     "    , .second(2)\n"
-     "    /* c2 */\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "        .first (1)\n"
-     "      /* c1 */\n"
-     "      , .second(2)\n"
-     "      /* c2 */\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    .first(1)\n"
-     "    /* c1 */\n"
-     "    , /* c2 */\n"
-     "    .second(2)\n"
-     "    /* c3 */\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "      .first (1)\n"
-     "      /* c1 */\n"
-     "      ,  /* c2 */\n"
-     "      .second(2)\n"
-     "      /* c3 */\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    .first(1)\n"
-     "    /* c1 */\n"
-     "    , /* c2 */\n"
-     "    .second(2)\n"
-     "    /* c3 */\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "      .first (1)\n"
-     "      /* c1 */\n"
-     "      ,  /* c2 */\n"
-     "      .second(2)\n"
-     "      /* c3 */\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-    {"module foo;\n"
-     "  bar#(\n"
-     "    /* c1  */\n"
-     "    /* c1+ */\n"
-     "    .first(1) /* c2  */\n"
-     "              /* c2+ */\n"
-     "    , /* c3  */\n"
-     "      /* c3+ */\n"
-     "    .second(2) /* c4  */\n"
-     "               /* c4+ */\n"
-     "    /* c5  */\n"
-     "    /* c5+ */\n"
-     "  ) baz ();\n"
-     "endmodule\n",
-     "module foo;\n"
-     "  bar #(\n"
-     "      /* c1  */\n"
-     "      /* c1+ */\n"
-     "      .first (1)  /* c2  */\n"
-     "      /* c2+ */\n"
-     "      ,  /* c3  */\n"
-     "      /* c3+ */\n"
-     "      .second(2)  /* c4  */\n"
-     "      /* c4+ */\n"
-     "      /* c5  */\n"
-     "      /* c5+ */\n"
-     "  ) baz ();\n"
-     "endmodule\n"},
-
-    // ":" and "'{" in a single line
-    {"assign foo[2] =\n"
-     "'{\n"
-     "bar: 1'b1,  // c\n"
-     "baz: 1'b0,  // c\n"
-     "foobar: CONSTANT,\n"
-     "qux:\n"
-     "{\n"
-     "a,  // c\n"
-     "b\n"
-     "}\n"
-     "};\n",
-     "assign foo[2] = '{\n"
-     "        bar: 1'b1,  // c\n"
-     "        baz: 1'b0,  // c\n"
-     "        foobar: CONSTANT,\n"
-     "        qux: {\n"
-     "          a,  // c\n"
-     "          b\n"
-     "        }\n"
-     "    };\n"},
-    {"assign a = (b) ? '{c: d[e], f: '1} : g;\n",
-     "assign a = (b) ?\n"
-     "    '{c: d[e], f: '1}\n"
-     "    : g;\n"},
-
-    // -----------------------------------------------------------------
-    // Comments around `else`.
-    // Check whether `else` partition is found correctly and that actual code is
-    // not appended to EOL comments.
-
-    // generate if
-
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "else if (r) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  else if (r) assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "else if (r) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  // eol-c\n"
-     "  else if (r) assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "else // eol-c\n"
-     "if (r) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  else  // eol-c\n"
-     "  if (r) assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "else\n"
-     "// eol-c\n"
-     "if (r) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  else\n"
-     "  // eol-c\n"
-     "  if (r)\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "if (r) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  else  // eol-c\n"
-     "  if (r) assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if (r) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  else  // eol-c\n"
-     "  // eol-c\n"
-     "  if (r)\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if (r) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  else  // eol-c\n"
-     "  // eol-c\n"
-     "  if (r)\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if\n"
-     "// eol-c\n"
-     "(r) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  else  // eol-c\n"
-     "  // eol-c\n"
-     "  if\n"
-     "      // eol-c\n"
-     "      (r)\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "if\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "(r) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  // eol-c\n"
-     "  else  // eol-c\n"
-     "  // eol-c\n"
-     "  // eol-c\n"
-     "  if\n"
-     "      // eol-c\n"
-     "      // eol-c\n"
-     "      (r)\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-
-    // generate if with function call
-
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "else if (foo(x) == bar(1, 2)) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  else if (foo(x) == bar(1, 2))\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "else if (foo(x) == bar(1, 2)) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  // eol-c\n"
-     "  else if (foo(x) == bar(1, 2))\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "else // eol-c\n"
-     "if (foo(x) == bar(1, 2)) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  else  // eol-c\n"
-     "  if (foo(x) == bar(1, 2)) assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "else\n"
-     "// eol-c\n"
-     "if (foo(x) == bar(1, 2)) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  else\n"
-     "  // eol-c\n"
-     "  if (foo(\n"
-     "          x\n"
-     "      ) == bar(\n"
-     "          1, 2\n"
-     "      ))\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "if (foo(x) == bar(1, 2)) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  else  // eol-c\n"
-     "  if (foo(x) == bar(1, 2)) assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if (foo(x) == bar(1, 2)) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  else  // eol-c\n"
-     "  // eol-c\n"
-     "  if (foo(\n"
-     "          x\n"
-     "      ) == bar(\n"
-     "          1, 2\n"
-     "      ))\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if (foo(x) == bar(1, 2)) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  else  // eol-c\n"
-     "  // eol-c\n"
-     "  if (foo(\n"
-     "          x\n"
-     "      ) == bar(\n"
-     "          1, 2\n"
-     "      ))\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if\n"
-     "// eol-c\n"
-     "(foo(x) == bar(1, 2)) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  else  // eol-c\n"
-     "  // eol-c\n"
-     "  if\n"
-     "      // eol-c\n"
-     "      (foo(\n"
-     "          x\n"
-     "      ) == bar(\n"
-     "          1, 2\n"
-     "      ))\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "if (x) assign z=y;\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "if\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "(foo(x) == bar(1, 2)) assign z=w;\n"
-     "else assign x=y;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  if (x) assign z = y;\n"
-     "  // eol-c\n"
-     "  // eol-c\n"
-     "  else  // eol-c\n"
-     "  // eol-c\n"
-     "  // eol-c\n"
-     "  if\n"
-     "      // eol-c\n"
-     "      // eol-c\n"
-     "      (foo(\n"
-     "          x\n"
-     "      ) == bar(\n"
-     "          1, 2\n"
-     "      ))\n"
-     "    assign z = w;\n"
-     "  else assign x = y;\n"
-     "endmodule\n"},
-
-    // else begin
-
-    {"module zx;\n"
-     "always begin\n"
-     "if (a) b<=1;\n"
-     "// eol-c\n"
-     "else begin b<=2;\n"
-     "end\n"
-     "end\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always begin\n"
-     "    if (a) b <= 1;\n"
-     "    // eol-c\n"
-     "    else begin\n"
-     "      b <= 2;\n"
-     "    end\n"
-     "  end\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always begin\n"
-     "if (a) b<=1;\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "else begin b<=2;\n"
-     "end\n"
-     "end\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always begin\n"
-     "    if (a) b <= 1;\n"
-     "    // eol-c\n"
-     "    // eol-c\n"
-     "    else begin\n"
-     "      b <= 2;\n"
-     "    end\n"
-     "  end\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always begin\n"
-     "if (a) b<=1;\n"
-     "else // eol-c\n"
-     "begin b<=2;\n"
-     "end\n"
-     "end\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always begin\n"
-     "    if (a) b <= 1;\n"
-     "    else  // eol-c\n"
-     "    begin\n"
-     "      b <= 2;\n"
-     "    end\n"
-     "  end\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always begin\n"
-     "if (a) b<=1;\n"
-     "else\n"
-     "// eol-c\n"
-     "begin b<=2;\n"
-     "end\n"
-     "end\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always begin\n"
-     "    if (a) b <= 1;\n"
-     "    else\n"
-     "    // eol-c\n"
-     "    begin\n"
-     "      b <= 2;\n"
-     "    end\n"
-     "  end\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always begin\n"
-     "if (a) b<=1;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "begin b<=2;\n"
-     "end\n"
-     "end\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always begin\n"
-     "    if (a) b <= 1;\n"
-     "    // eol-c\n"
-     "    else  // eol-c\n"
-     "    begin\n"
-     "      b <= 2;\n"
-     "    end\n"
-     "  end\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always begin\n"
-     "if (a) b<=1;\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "begin b<=2;\n"
-     "end\n"
-     "end\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always begin\n"
-     "    if (a) b <= 1;\n"
-     "    else  // eol-c\n"
-     "    // eol-c\n"
-     "    begin\n"
-     "      b <= 2;\n"
-     "    end\n"
-     "  end\n"
-     "endmodule\n"},
-
-    // else if
-
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "else if (set) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    else if (set) assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "else if (set) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    // eol-c\n"
-     "    else if (set) assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "else // eol-c\n"
-     "if (set) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    else  // eol-c\n"
-     "    if (set) assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "else\n"
-     "// eol-c\n"
-     "if (set) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    else\n"
-     "    // eol-c\n"
-     "    if (set)\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "if (set) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    else  // eol-c\n"
-     "    if (set) assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if (set) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    else  // eol-c\n"
-     "    // eol-c\n"
-     "    if (set)\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if (set) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    else  // eol-c\n"
-     "    // eol-c\n"
-     "    if (set)\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if\n"
-     "// eol-c\n"
-     "(set) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    else  // eol-c\n"
-     "    // eol-c\n"
-     "    if\n"
-     "        // eol-c\n"
-     "        (set)\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "if\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "(set) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    // eol-c\n"
-     "    else  // eol-c\n"
-     "    // eol-c\n"
-     "    // eol-c\n"
-     "    if\n"
-     "        // eol-c\n"
-     "        // eol-c\n"
-     "        (set)\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-
-    // else if with function call
-
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "else if (foo(clr, set, 1)) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    else if (foo(clr, set, 1))\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "else if (foo(clr, set, 1)) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    // eol-c\n"
-     "    else if (foo(clr, set, 1))\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "else // eol-c\n"
-     "if (foo(clr, set, 1)) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    else  // eol-c\n"
-     "    if (foo(clr, set, 1)) assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "else\n"
-     "// eol-c\n"
-     "if (foo(clr, set, 1)) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    else\n"
-     "    // eol-c\n"
-     "    if (foo(\n"
-     "            clr, set, 1\n"
-     "        ))\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "if (foo(clr, set, 1)) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    else  // eol-c\n"
-     "    if (foo(clr, set, 1)) assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if (foo(clr, set, 1)) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    else  // eol-c\n"
-     "    // eol-c\n"
-     "    if (foo(\n"
-     "            clr, set, 1\n"
-     "        ))\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if (foo(clr, set, 1)) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    else  // eol-c\n"
-     "    // eol-c\n"
-     "    if (foo(\n"
-     "            clr, set, 1\n"
-     "        ))\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "if\n"
-     "// eol-c\n"
-     "(foo(clr, set, 1)) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    else  // eol-c\n"
-     "    // eol-c\n"
-     "    if\n"
-     "        // eol-c\n"
-     "        (foo(\n"
-     "            clr, set, 1\n"
-     "        ))\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-    {"module zx;\n"
-     "always @(clr or set)\n"
-     "if (clr) assign q=0;\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "else // eol-c\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "if\n"
-     "// eol-c\n"
-     "// eol-c\n"
-     "(foo(clr, set, 1)) assign q=1;\n"
-     "else deassign q;\n"
-     "endmodule\n",
-     "module zx;\n"
-     "  always @(clr or set)\n"
-     "    if (clr) assign q = 0;\n"
-     "    // eol-c\n"
-     "    // eol-c\n"
-     "    else  // eol-c\n"
-     "    // eol-c\n"
-     "    // eol-c\n"
-     "    if\n"
-     "        // eol-c\n"
-     "        // eol-c\n"
-     "        (foo(\n"
-     "            clr, set, 1\n"
-     "        ))\n"
-     "      assign q = 1;\n"
-     "    else deassign q;\n"
-     "endmodule\n"},
-
-    // -----------------------------------------------------------------
-    // Comments around and inside macro calls.
-
-    // between identifier and '(', no args
-
-    {"// verilog_syntax: parse-as-module-body",
-     "// verilog_syntax: parse-as-module-body\n"},
-    {"// verilog_syntax: parse-as-statements",
-     "// verilog_syntax: parse-as-statements\n"},
-    {"// verilog_syntax: parse-as-class-body",
-     "// verilog_syntax: parse-as-class-body\n"},
-    {"// verilog_syntax: parse-as-package-body",
-     "// verilog_syntax: parse-as-package-body\n"},
-    {"// verilog_syntax: parse-as-library-map",
-     "// verilog_syntax: parse-as-library-map\n"},
-    {"// verilog_syntax: does-not-exist-mode",
-     "// verilog_syntax: does-not-exist-mode\n"},
-    {"// verilog_syntax: parse-as-module-body\n",
-     "// verilog_syntax: parse-as-module-body\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "// comment",
-     "// verilog_syntax: parse-as-module-body\n"
-     "// comment\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c */ ();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c */ ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */ /* c2 */ ();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  /* c2 */ ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c */\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c */\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */ /* c2 */\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  /* c2 */\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz // c\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */ // c2\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  // c2\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c */ ();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c */ ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ /* c2 */ ();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  /* c2 */ ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c */\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c */\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ /* c2 */\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  /* c2 */\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "// c\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    // c\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ // c2\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  // c2\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "// c1\n"
-     "// c2\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    // c1\n"
-     "    // c2\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */\n"
-     "/* c2 */ ();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */ ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz // c1\n"
-     "/* c2 */ ();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    /* c2 */ ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */ ();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */ ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */\n"
-     "/* c2 */\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz // c1\n"
-     "/* c2 */\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    /* c2 */\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */\n"
-     "// c2\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    // c2\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz // c1\n"
-     "// c2\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    // c2\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     "    ();\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz // c1\n"
-     "// c2\n"
-     "// c3\n"
-     "();\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     "    ();\n"},
-
-    // between identifier and '(', with arg
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c */ (arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c */ (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */ /* c2 */ (arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  /* c2 */ (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c */\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c */\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */ /* c2 */\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  /* c2 */\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz // c\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */ // c2\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  // c2\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c */ (arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c */ (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ /* c2 */ (arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  /* c2 */ (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c */\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c */\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ /* c2 */\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  /* c2 */\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "// c\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    // c\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ // c2\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  // c2\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "// c1\n"
-     "// c2\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    // c1\n"
-     "    // c2\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */\n"
-     "/* c2 */ (arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */ (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz // c1\n"
-     "/* c2 */ (arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    /* c2 */ (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */ (arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */ (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */\n"
-     "/* c2 */\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz // c1\n"
-     "/* c2 */\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    /* c2 */\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */\n"
-     "// c2\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    // c2\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz // c1\n"
-     "// c2\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    // c2\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     "    (arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz // c1\n"
-     "// c2\n"
-     "// c3\n"
-     "(arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     "    (arg);\n"},
-
-    // after '(', no args
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    // c1\n"
-     "    // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(// c1\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  // c1\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */\n"
-     "    /* c2 */\n"
-     "/* c3 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */\n"
-     "    /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(// c1\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  // c1\n"
-     "    /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */\n"
-     "    // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  // c1\n"
-     "    // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    // c1\n"
-     "    // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     "/* c3 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     ");\n"},
-
-    // after '(', with arg
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */ /* c2 */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */  /* c2 */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */ /* c2 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */  /* c2 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(// c\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  // c\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */ // c2\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */  // c2\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    /* c */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c1 */ /* c2 */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    /* c1 */  /* c2 */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    /* c */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c1 */ /* c2 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    /* c1 */  /* c2 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "// c\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    // c\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c1 */ // c2\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    /* c1 */  // c2\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "// c1\n"
-     "// c2\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(\n"
-     "    // c1\n"
-     "    // c2\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */\n"
-     "/* c2 */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */\n"
-     "    /* c2 */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(// c1\n"
-     "/* c2 */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  // c1\n"
-     "    /* c2 */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */\n"
-     "/* c2 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(// c1\n"
-     "/* c2 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  // c1\n"
-     "    /* c2 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */\n"
-     "// c2\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */\n"
-     "    // c2\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(// c1\n"
-     "// c2\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  // c1\n"
-     "    // c2\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(// c1\n"
-     "// c2\n"
-     "// c3\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ /* c2 */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  /* c2 */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ /* c2 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  /* c2 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ // c2\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  // c2\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ /* c2 */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */  /* c2 */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ /* c2 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */  /* c2 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "// c\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    // c\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ // c2\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */  // c2\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "// c1\n"
-     "// c2\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    // c1\n"
-     "    // c2\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "/* c2 */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    /* c2 */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */ arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "/* c2 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    /* c2 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "// c2\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    // c2\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "// c2\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    // c2\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     "    arg);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "// c2\n"
-     "// c3\n"
-     "arg);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     "    arg);\n"},
-
-    // after single arg
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  /* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  /* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "/* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "/* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "           /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "           /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "           // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "           /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "           /* c1 */\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg\n"
-     "           // c1\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg/* c1 */\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  /* c1 */\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg// c1\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  // c1\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  /* c1 */\n"
-     "           /* c2 */\n"
-     "/* c3 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  /* c1 */\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg// c1\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  // c1\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg/* c1 */\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  /* c1 */\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  // c1\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg  // c1\n"
-     "           // c2\n"
-     "           // c3\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  /* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  /* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "/* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "/* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "           /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "           /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "           // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "           /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "           /* c1 */\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg\n"
-     "           // c1\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg/* c1 */\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  /* c1 */\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg// c1\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  // c1\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  /* c1 */\n"
-     "           /* c2 */\n"
-     "/* c3 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  /* c1 */\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg// c1\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  // c1\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg/* c1 */\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  /* c1 */\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  // c1\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg  // c1\n"
-     "           // c2\n"
-     "           // c3\n"
-     ");\n"},
-
-    // before colon
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1/* c */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  /* c */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1/* c1 */ /* c2 */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  /* c1 */  /* c2 */,\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1/* c */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  /* c */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1/* c1 */ /* c2 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  /* c1 */  /* c2 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1// c\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  // c\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1/* c1 */ // c2\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  /* c1 */  // c2\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "/* c */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "           /* c */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "/* c1 */ /* c2 */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "           /* c1 */  /* c2 */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "/* c */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "           /* c */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "/* c1 */ /* c2 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "           /* c1 */  /* c2 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "// c\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "           // c\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "/* c1 */ // c2\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "           /* c1 */  // c2\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "           /* c1 */\n"
-     "           /* c2 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "// c1\n"
-     "// c2\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1\n"
-     "           // c1\n"
-     "           // c2\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1/* c1 */\n"
-     "/* c2 */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  /* c1 */\n"
-     "           /* c2 */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1// c1\n"
-     "/* c2 */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  // c1\n"
-     "           /* c2 */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1/* c1 */\n"
-     "/* c2 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  /* c1 */\n"
-     "           /* c2 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1// c1\n"
-     "/* c2 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  // c1\n"
-     "           /* c2 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1/* c1 */\n"
-     "// c2\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  /* c1 */\n"
-     "           // c2\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1// c1\n"
-     "// c2\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  // c1\n"
-     "           // c2\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1  // c1\n"
-     "           // c2\n"
-     "           // c3\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1/* c */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  /* c */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1/* c1 */ /* c2 */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  /* c1 */  /* c2 */,\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1/* c */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  /* c */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1/* c1 */ /* c2 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  /* c1 */  /* c2 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1// c\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  // c\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1/* c1 */ // c2\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  /* c1 */  // c2\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "/* c */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "           /* c */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "/* c1 */ /* c2 */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "           /* c1 */  /* c2 */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "/* c */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "           /* c */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "/* c1 */ /* c2 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "           /* c1 */  /* c2 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "// c\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "           // c\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "/* c1 */ // c2\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "           /* c1 */  // c2\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "           /* c1 */\n"
-     "           /* c2 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "// c1\n"
-     "// c2\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1\n"
-     "           // c1\n"
-     "           // c2\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1/* c1 */\n"
-     "/* c2 */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  /* c1 */\n"
-     "           /* c2 */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1// c1\n"
-     "/* c2 */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  // c1\n"
-     "           /* c2 */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */, arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */, arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1/* c1 */\n"
-     "/* c2 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  /* c1 */\n"
-     "           /* c2 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1// c1\n"
-     "/* c2 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  // c1\n"
-     "           /* c2 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1/* c1 */\n"
-     "// c2\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  /* c1 */\n"
-     "           // c2\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1// c1\n"
-     "// c2\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  // c1\n"
-     "           // c2\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */\n"
-     "           , arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ", arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1  // c1\n"
-     "           // c2\n"
-     "           // c3\n"
-     "           , arg2);\n"},
-
-    // after colon
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,/* c */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  /* c */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,/* c1 */ /* c2 */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  /* c1 */  /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,/* c */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  /* c */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,/* c1 */ /* c2 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  /* c1 */  /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,// c\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  // c\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,/* c1 */ // c2\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  /* c1 */  // c2\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "/* c */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "           /* c */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "/* c1 */ /* c2 */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "           /* c1 */  /* c2 */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "/* c */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "           /* c */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "/* c1 */ /* c2 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "           /* c1 */  /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "// c\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "           // c\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "/* c1 */ // c2\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "           /* c1 */  // c2\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "           /* c1 */\n"
-     "           /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "// c1\n"
-     "// c2\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "           // c1\n"
-     "           // c2\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,/* c1 */\n"
-     "/* c2 */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  /* c1 */\n"
-     "           /* c2 */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,// c1\n"
-     "/* c2 */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  // c1\n"
-     "           /* c2 */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,/* c1 */\n"
-     "/* c2 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  /* c1 */\n"
-     "           /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,// c1\n"
-     "/* c2 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  // c1\n"
-     "           /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,/* c1 */\n"
-     "// c2\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  /* c1 */\n"
-     "           // c2\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,// c1\n"
-     "// c2\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  // c1\n"
-     "           // c2\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,// c1\n"
-     "// c2\n"
-     "// c3\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,  // c1\n"
-     "           // c2\n"
-     "           // c3\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,/* c */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  /* c */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,/* c1 */ /* c2 */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  /* c1 */  /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,/* c */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  /* c */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,/* c1 */ /* c2 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  /* c1 */  /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,// c\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  // c\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,/* c1 */ // c2\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  /* c1 */  // c2\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "/* c */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "           /* c */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "/* c1 */ /* c2 */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "           /* c1 */  /* c2 */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "/* c */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "           /* c */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "/* c1 */ /* c2 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "           /* c1 */  /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "// c\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "           // c\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "/* c1 */ // c2\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "           /* c1 */  // c2\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "           /* c1 */\n"
-     "           /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "// c1\n"
-     "// c2\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "           // c1\n"
-     "           // c2\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,/* c1 */\n"
-     "/* c2 */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  /* c1 */\n"
-     "           /* c2 */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,// c1\n"
-     "/* c2 */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  // c1\n"
-     "           /* c2 */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */ arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,/* c1 */\n"
-     "/* c2 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  /* c1 */\n"
-     "           /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,// c1\n"
-     "/* c2 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  // c1\n"
-     "           /* c2 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,/* c1 */\n"
-     "// c2\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  /* c1 */\n"
-     "           // c2\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,// c1\n"
-     "// c2\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  // c1\n"
-     "           // c2\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */\n"
-     "           arg2);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,// c1\n"
-     "// c2\n"
-     "// c3\n"
-     "arg2);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,  // c1\n"
-     "           // c2\n"
-     "           // c3\n"
-     "           arg2);\n"},
-
-    // after last arg
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  /* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "           arg2,  /* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1,\n"
-     "           arg2,  /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "/* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "/* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "           /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "           /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "           // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "           /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "           /* c1 */\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,\n"
-     "           // c1\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,/* c1 */\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  /* c1 */\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,// c1\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  // c1\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  /* c1 */\n"
-     "           /* c2 */\n"
-     "/* c3 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  /* c1 */\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,// c1\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  // c1\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,/* c1 */\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  /* c1 */\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  // c1\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg1, arg2,  // c1\n"
-     "           // c2\n"
-     "           // c3\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  /* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "           arg2,  /* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1,\n"
-     "           arg2,  /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "/* c */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "/* c */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "/* c1 */ /* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "/* c1 */  /* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "/* c */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "           /* c */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "/* c1 */ /* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "           /* c1 */  /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "// c\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "           // c\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "/* c1 */ // c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "           /* c1 */  // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "           /* c1 */\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,\n"
-     "           // c1\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,/* c1 */\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  /* c1 */\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,// c1\n"
-     "/* c2 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  // c1\n"
-     "/* c2 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */);\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  /* c1 */\n"
-     "           /* c2 */\n"
-     "/* c3 */);\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,/* c1 */\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  /* c1 */\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,// c1\n"
-     "/* c2 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  // c1\n"
-     "           /* c2 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,/* c1 */\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  /* c1 */\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,// c1\n"
-     "// c2\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  // c1\n"
-     "           // c2\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  /* c1 */\n"
-     "           /* c2 */\n"
-     "           /* c3 */\n"
-     ");\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ");\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg1, arg2,  // c1\n"
-     "           // c2\n"
-     "           // c3\n"
-     ");\n"},
-
-    // after ')', no args
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()/* c */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  /* c */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()/* c1 */ /* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  /* c1 */  /* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()/* c */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  /* c */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()/* c1 */ /* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  /* c1 */  /* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()// c\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  // c\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()/* c1 */ // c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  /* c1 */  // c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c1 */ /* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c1 */  /* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c1 */ /* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c1 */  /* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "// c\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "// c\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c1 */ // c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c1 */  // c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()/* c1 */\n"
-     "/* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  /* c1 */\n"
-     "/* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()// c1\n"
-     "/* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  // c1\n"
-     "/* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()/* c1 */\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  /* c1 */\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()// c1\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  // c1\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()/* c1 */\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  /* c1 */\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()// c1\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  // c1\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz()  // c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()/* c */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  /* c */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()/* c1 */ /* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  /* c1 */  /* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()/* c */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  /* c */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()/* c1 */ /* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  /* c1 */  /* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()// c\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  // c\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()/* c1 */ // c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  /* c1 */  // c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c1 */ /* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c1 */  /* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c1 */ /* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c1 */  /* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "// c\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "// c\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c1 */ // c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c1 */  // c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()/* c1 */\n"
-     "/* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  /* c1 */\n"
-     "/* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()// c1\n"
-     "/* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  // c1\n"
-     "/* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()/* c1 */\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  /* c1 */\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()// c1\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  // c1\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()/* c1 */\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  /* c1 */\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()// c1\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  // c1\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ()  // c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";\n"},
-
-    // after ')', with arg
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)/* c */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  /* c */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)/* c1 */ /* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  /* c1 */  /* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)/* c */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  /* c */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)/* c1 */ /* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  /* c1 */  /* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)// c\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  // c\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)/* c1 */ // c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  /* c1 */  // c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c1 */ /* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c1 */  /* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c1 */ /* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c1 */  /* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "// c\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  // c\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c1 */ // c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c1 */  // c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)/* c1 */\n"
-     "/* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  /* c1 */\n"
-     "/* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)// c1\n"
-     "/* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  // c1\n"
-     "/* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)/* c1 */\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  /* c1 */\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)// c1\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  // c1\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)/* c1 */\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  /* c1 */\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)// c1\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  // c1\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg)  // c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)/* c */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  /* c */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)/* c1 */ /* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  /* c1 */  /* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)/* c */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  /* c */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)/* c1 */ /* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  /* c1 */  /* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)// c\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  // c\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)/* c1 */ // c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  /* c1 */  // c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c1 */ /* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c1 */  /* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c1 */ /* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c1 */  /* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "// c\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "// c\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c1 */ // c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c1 */  // c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)/* c1 */\n"
-     "/* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  /* c1 */\n"
-     "/* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)// c1\n"
-     "/* c2 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  // c1\n"
-     "/* c2 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)/* c1 */\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  /* c1 */\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)// c1\n"
-     "/* c2 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  // c1\n"
-     "/* c2 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)/* c1 */\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  /* c1 */\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)// c1\n"
-     "// c2\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  // c1\n"
-     "// c2\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg)  // c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";\n"},
-
-    // after ';', no args
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  // c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  /* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "// c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "/* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();\n"
-     "// c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();// c1 c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  // c1 c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();/* c1 */\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  /* c1 */\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  // c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();// c1\n"
-     "// c2\n"
-     "// c3\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz();  // c1\n"
-     "// c2\n"
-     "// c3\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  // c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  /* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "// c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "/* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();\n"
-     "// c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();/* c1 */\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  /* c1 */\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  // c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();// c1\n"
-     "// c2\n"
-     "// c3\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ();  // c1\n"
-     "// c2\n"
-     "// c3\n"},
-
-    // after ';', with arg
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  // c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  /* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "// c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "/* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);\n"
-     "// c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);// c1 c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  // c1 c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);/* c1 */\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  /* c1 */\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  // c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);// c1\n"
-     "// c2\n"
-     "// c3\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz(arg);  // c1\n"
-     "// c2\n"
-     "// c3\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  // c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  /* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "// c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "/* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);\n"
-     "// c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);/* c1 */\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  /* c1 */\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  // c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);// c1\n"
-     "// c2\n"
-     "// c3\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(arg);  // c1\n"
-     "// c2\n"
-     "// c3\n"},
-
-    // everywhere, no args
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c */(/* c */)/* c */;/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c */\n"
-     "    (  /* c */)  /* c */;  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */ /* c2 */(/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ "
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  /* c2 */\n"
-     "    (  /* c1 */  /* c2 */)  /* c1 */  /* c2 */;  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c */\n"
-     "(/* c */\n"
-     ")/* c */\n"
-     ";/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c */\n"
-     "    (  /* c */\n"
-     "    )  /* c */\n"
-     ";  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */ /* c2 */\n"
-     "(/* c1 */ /* c2 */\n"
-     ")/* c1 */ /* c2 */\n"
-     ";/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  /* c2 */\n"
-     "    (  /* c1 */  /* c2 */\n"
-     "    )  /* c1 */  /* c2 */\n"
-     ";  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz// c\n"
-     "(// c\n"
-     ")// c\n"
-     ";// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c\n"
-     "    (  // c\n"
-     "    )  // c\n"
-     ";  // c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */ // c2\n"
-     "(/* c1 */ // c2\n"
-     ")/* c1 */ // c2\n"
-     ";/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  // c2\n"
-     "    (  /* c1 */  // c2\n"
-     "    )  /* c1 */  // c2\n"
-     ";  /* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c */(\n"
-     "/* c */)\n"
-     "/* c */;\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c */ (\n"
-     "    /* c */)\n"
-     "/* c */;\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ /* c2 */(\n"
-     "/* c1 */ /* c2 */)\n"
-     "/* c1 */ /* c2 */;\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  /* c2 */ (\n"
-     "    /* c1 */  /* c2 */)\n"
-     "/* c1 */  /* c2 */;\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c */\n"
-     "(\n"
-     "/* c */\n"
-     ")\n"
-     "/* c */\n"
-     ";\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c */\n"
-     "    (\n"
-     "        /* c */\n"
-     "    )\n"
-     "/* c */\n"
-     ";\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ /* c2 */\n"
-     "(\n"
-     "/* c1 */ /* c2 */\n"
-     ")\n"
-     "/* c1 */ /* c2 */\n"
-     ";\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  /* c2 */\n"
-     "    (\n"
-     "        /* c1 */  /* c2 */\n"
-     "    )\n"
-     "/* c1 */  /* c2 */\n"
-     ";\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "// c\n"
-     "(\n"
-     "// c\n"
-     ")\n"
-     "// c\n"
-     ";\n"
-     "// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    // c\n"
-     "    (\n"
-     "        // c\n"
-     "    )\n"
-     "// c\n"
-     ";\n"
-     "// c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ // c2\n"
-     "(\n"
-     "/* c1 */ // c2\n"
-     ")\n"
-     "/* c1 */ // c2\n"
-     ";\n"
-     "/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  // c2\n"
-     "    (\n"
-     "        /* c1 */  // c2\n"
-     "    )\n"
-     "/* c1 */  // c2\n"
-     ";\n"
-     "/* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "(\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ")\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"
-     "/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     "    (\n"
-     "        /* c1 */\n"
-     "        /* c2 */\n"
-     "    )\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"
-     "/* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "// c1\n"
-     "// c2\n"
-     "(\n"
-     "// c1\n"
-     "// c2\n"
-     ")\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"
-     "// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    // c1\n"
-     "    // c2\n"
-     "    (\n"
-     "        // c1\n"
-     "        // c2\n"
-     "    )\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"
-     "// c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */\n"
-     "/* c2 */(/* c1 */\n"
-     "/* c2 */)/* c1 */\n"
-     "/* c2 */;/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */ (  /* c1 */\n"
-     "    /* c2 */)  /* c1 */\n"
-     "/* c2 */;  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz// c1\n"
-     "/* c2 */(// c1\n"
-     "/* c2 */)// c1\n"
-     "/* c2 */;// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    /* c2 */ (  // c1\n"
-     "    /* c2 */)  // c1\n"
-     "/* c2 */;  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */)/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */ (  /* c1 */\n"
-     "        /* c2 */\n"
-     "    /* c3 */)  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */\n"
-     "/* c2 */\n"
-     "(/* c1 */\n"
-     "/* c2 */\n"
-     ")/* c1 */\n"
-     "/* c2 */\n"
-     ";/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    (  /* c1 */\n"
-     "        /* c2 */\n"
-     "    )  /* c1 */\n"
-     "/* c2 */\n"
-     ";  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz// c1\n"
-     "/* c2 */\n"
-     "(// c1\n"
-     "/* c2 */\n"
-     ")// c1\n"
-     "/* c2 */\n"
-     ";// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    /* c2 */\n"
-     "    (  // c1\n"
-     "        /* c2 */\n"
-     "    )  // c1\n"
-     "/* c2 */\n"
-     ";  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */\n"
-     "// c2\n"
-     "(/* c1 */\n"
-     "// c2\n"
-     ")/* c1 */\n"
-     "// c2\n"
-     ";/* c1 */\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    // c2\n"
-     "    (  /* c1 */\n"
-     "        // c2\n"
-     "    )  /* c1 */\n"
-     "// c2\n"
-     ";  /* c1 */\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz// c1\n"
-     "// c2\n"
-     "(// c1\n"
-     "// c2\n"
-     ")// c1\n"
-     "// c2\n"
-     ";// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    // c2\n"
-     "    (  // c1\n"
-     "       // c2\n"
-     "    )  // c1\n"
-     "       // c2\n"
-     ";  // c1\n"
-     "   // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ")/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     "    (  /* c1 */\n"
-     "        /* c2 */\n"
-     "        /* c3 */\n"
-     "    )  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz// c1\n"
-     "// c2\n"
-     "// c3\n"
-     "(// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ")// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";// c1\n"
-     "// c2\n"
-     "// c3\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     "    (  // c1\n"
-     "       // c2\n"
-     "       // c3\n"
-     "    )  // c1\n"
-     "       // c2\n"
-     "       // c3\n"
-     ";  // c1\n"
-     "   // c2\n"
-     "   // c3\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c */)/* c */;/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c */)  /* c */;  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  /* c2 */)  /* c1 */  /* c2 */;  /* c1 */  /* c2 "
-     "*/\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c */\n"
-     ")/* c */\n"
-     ";/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c */\n"
-     ")  /* c */\n"
-     ";  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ /* c2 */\n"
-     ")/* c1 */ /* c2 */\n"
-     ";/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  /* c2 */\n"
-     ")  /* c1 */  /* c2 */\n"
-     ";  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c\n"
-     ")// c\n"
-     ";// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c\n"
-     ")  // c\n"
-     ";  // c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ // c2\n"
-     ")/* c1 */ // c2\n"
-     ";/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  // c2\n"
-     ")  /* c1 */  // c2\n"
-     ";  /* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c */)\n"
-     "/* c */;\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c */)\n"
-     "/* c */;\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ /* c2 */)\n"
-     "/* c1 */ /* c2 */;\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */  /* c2 */)\n"
-     "/* c1 */  /* c2 */;\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c */\n"
-     ")\n"
-     "/* c */\n"
-     ";\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c */\n"
-     ")\n"
-     "/* c */\n"
-     ";\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ /* c2 */\n"
-     ")\n"
-     "/* c1 */ /* c2 */\n"
-     ";\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */  /* c2 */\n"
-     ")\n"
-     "/* c1 */  /* c2 */\n"
-     ";\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "// c\n"
-     ")\n"
-     "// c\n"
-     ";\n"
-     "// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    // c\n"
-     ")\n"
-     "// c\n"
-     ";\n"
-     "// c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ // c2\n"
-     ")\n"
-     "/* c1 */ // c2\n"
-     ";\n"
-     "/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */  // c2\n"
-     ")\n"
-     "/* c1 */  // c2\n"
-     ";\n"
-     "/* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ")\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"
-     "/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     ")\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"
-     "/* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "// c1\n"
-     "// c2\n"
-     ")\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"
-     "// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    // c1\n"
-     "    // c2\n"
-     ")\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"
-     "// c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */)/* c1 */\n"
-     "/* c2 */;/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "/* c2 */)  /* c1 */\n"
-     "/* c2 */;  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "/* c2 */)// c1\n"
-     "/* c2 */;// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "/* c2 */)  // c1\n"
-     "/* c2 */;  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */)/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     "/* c3 */)  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     ")/* c1 */\n"
-     "/* c2 */\n"
-     ";/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     ")  /* c1 */\n"
-     "/* c2 */\n"
-     ";  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "/* c2 */\n"
-     ")// c1\n"
-     "/* c2 */\n"
-     ";// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    /* c2 */\n"
-     ")  // c1\n"
-     "/* c2 */\n"
-     ";  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "// c2\n"
-     ")/* c1 */\n"
-     "// c2\n"
-     ";/* c1 */\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    // c2\n"
-     ")  /* c1 */\n"
-     "// c2\n"
-     ";  /* c1 */\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "// c2\n"
-     ")// c1\n"
-     "// c2\n"
-     ";// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    // c2\n"
-     ")  // c1\n"
-     "   // c2\n"
-     ";  // c1\n"
-     "   // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ")/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     ")  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ")// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";// c1\n"
-     "// c2\n"
-     "// c3\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     ")  // c1\n"
-     "   // c2\n"
-     "   // c3\n"
-     ";  // c1\n"
-     "   // c2\n"
-     "   // c3\n"},
-
-    // everywhere, with args
-
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c */(/* c */arg1/* c */,/* c */arg2/* c */)/* c */;/* c "
-     "*/\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c */ (  /* c */\n"
-     "    arg1  /* c */,  /* c */\n"
-     "    arg2  /* c */)  /* c */;  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */ /* c2 */(/* c1 */ /* c2 */arg1/* c1 */ /* c2 */,/* c1 "
-     "*/ /* c2 */arg2/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  /* c2 */ (  /* c1 */  /* c2 */\n"
-     "    arg1  /* c1 */  /* c2 */,  /* c1 */  /* c2 */\n"
-     "    arg2  /* c1 */  /* c2 */)  /* c1 */  /* c2 */;  /* c1 */  /* c2 "
-     "*/\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c */\n"
-     "(/* c */\n"
-     "arg1/* c */\n"
-     ",/* c */\n"
-     "arg2/* c */\n"
-     ")/* c */\n"
-     ";/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c */\n"
-     "    (  /* c */\n"
-     "        arg1  /* c */\n"
-     "        ,  /* c */\n"
-     "        arg2  /* c */\n"
-     "    )  /* c */\n"
-     ";  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */ /* c2 */\n"
-     "(/* c1 */ /* c2 */\n"
-     "arg1/* c1 */ /* c2 */\n"
-     ",/* c1 */ /* c2 */\n"
-     "arg2/* c1 */ /* c2 */\n"
-     ")/* c1 */ /* c2 */\n"
-     ";/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  /* c2 */\n"
-     "    (  /* c1 */  /* c2 */\n"
-     "        arg1  /* c1 */  /* c2 */\n"
-     "        ,  /* c1 */  /* c2 */\n"
-     "        arg2  /* c1 */  /* c2 */\n"
-     "    )  /* c1 */  /* c2 */\n"
-     ";  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz// c\n"
-     "(// c\n"
-     "arg1// c\n"
-     ",// c\n"
-     "arg2// c\n"
-     ")// c\n"
-     ";// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c\n"
-     "    (  // c\n"
-     "        arg1  // c\n"
-     "        ,  // c\n"
-     "        arg2  // c\n"
-     "    )  // c\n"
-     ";  // c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */ // c2\n"
-     "(/* c1 */ // c2\n"
-     "arg1/* c1 */ // c2\n"
-     ",/* c1 */ // c2\n"
-     "arg2/* c1 */ // c2\n"
-     ")/* c1 */ // c2\n"
-     ";/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */  // c2\n"
-     "    (  /* c1 */  // c2\n"
-     "        arg1  /* c1 */  // c2\n"
-     "        ,  /* c1 */  // c2\n"
-     "        arg2  /* c1 */  // c2\n"
-     "    )  /* c1 */  // c2\n"
-     ";  /* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c */(\n"
-     "/* c */arg1\n"
-     "/* c */,\n"
-     "/* c */arg2\n"
-     "/* c */)\n"
-     "/* c */;\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c */ (\n"
-     "        /* c */ arg1\n"
-     "        /* c */,\n"
-     "        /* c */ arg2\n"
-     "    /* c */)\n"
-     "/* c */;\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ /* c2 */(\n"
-     "/* c1 */ /* c2 */arg1\n"
-     "/* c1 */ /* c2 */,\n"
-     "/* c1 */ /* c2 */arg2\n"
-     "/* c1 */ /* c2 */)\n"
-     "/* c1 */ /* c2 */;\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  /* c2 */ (\n"
-     "        /* c1 */  /* c2 */ arg1\n"
-     "        /* c1 */  /* c2 */,\n"
-     "        /* c1 */  /* c2 */ arg2\n"
-     "    /* c1 */  /* c2 */)\n"
-     "/* c1 */  /* c2 */;\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c */\n"
-     "(\n"
-     "/* c */\n"
-     "arg1\n"
-     "/* c */\n"
-     ",\n"
-     "/* c */\n"
-     "arg2\n"
-     "/* c */\n"
-     ")\n"
-     "/* c */\n"
-     ";\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c */\n"
-     "    (\n"
-     "        /* c */\n"
-     "        arg1\n"
-     "        /* c */\n"
-     "        ,\n"
-     "        /* c */\n"
-     "        arg2\n"
-     "        /* c */\n"
-     "    )\n"
-     "/* c */\n"
-     ";\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ /* c2 */\n"
-     "(\n"
-     "/* c1 */ /* c2 */\n"
-     "arg1\n"
-     "/* c1 */ /* c2 */\n"
-     ",\n"
-     "/* c1 */ /* c2 */\n"
-     "arg2\n"
-     "/* c1 */ /* c2 */\n"
-     ")\n"
-     "/* c1 */ /* c2 */\n"
-     ";\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  /* c2 */\n"
-     "    (\n"
-     "        /* c1 */  /* c2 */\n"
-     "        arg1\n"
-     "        /* c1 */  /* c2 */\n"
-     "        ,\n"
-     "        /* c1 */  /* c2 */\n"
-     "        arg2\n"
-     "        /* c1 */  /* c2 */\n"
-     "    )\n"
-     "/* c1 */  /* c2 */\n"
-     ";\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "// c\n"
-     "(\n"
-     "// c\n"
-     "arg1\n"
-     "// c\n"
-     ",\n"
-     "// c\n"
-     "arg2\n"
-     "// c\n"
-     ")\n"
-     "// c\n"
-     ";\n"
-     "// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    // c\n"
-     "    (\n"
-     "        // c\n"
-     "        arg1\n"
-     "        // c\n"
-     "        ,\n"
-     "        // c\n"
-     "        arg2\n"
-     "        // c\n"
-     "    )\n"
-     "// c\n"
-     ";\n"
-     "// c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */ // c2\n"
-     "(\n"
-     "/* c1 */ // c2\n"
-     "arg1\n"
-     "/* c1 */ // c2\n"
-     ",\n"
-     "/* c1 */ // c2\n"
-     "arg2\n"
-     "/* c1 */ // c2\n"
-     ")\n"
-     "/* c1 */ // c2\n"
-     ";\n"
-     "/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */  // c2\n"
-     "    (\n"
-     "        /* c1 */  // c2\n"
-     "        arg1\n"
-     "        /* c1 */  // c2\n"
-     "        ,\n"
-     "        /* c1 */  // c2\n"
-     "        arg2\n"
-     "        /* c1 */  // c2\n"
-     "    )\n"
-     "/* c1 */  // c2\n"
-     ";\n"
-     "/* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "(\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "arg1\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ",\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "arg2\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ")\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"
-     "/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     "    (\n"
-     "        /* c1 */\n"
-     "        /* c2 */\n"
-     "        arg1\n"
-     "        /* c1 */\n"
-     "        /* c2 */\n"
-     "        ,\n"
-     "        /* c1 */\n"
-     "        /* c2 */\n"
-     "        arg2\n"
-     "        /* c1 */\n"
-     "        /* c2 */\n"
-     "    )\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"
-     "/* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "// c1\n"
-     "// c2\n"
-     "(\n"
-     "// c1\n"
-     "// c2\n"
-     "arg1\n"
-     "// c1\n"
-     "// c2\n"
-     ",\n"
-     "// c1\n"
-     "// c2\n"
-     "arg2\n"
-     "// c1\n"
-     "// c2\n"
-     ")\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"
-     "// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz\n"
-     "    // c1\n"
-     "    // c2\n"
-     "    (\n"
-     "        // c1\n"
-     "        // c2\n"
-     "        arg1\n"
-     "        // c1\n"
-     "        // c2\n"
-     "        ,\n"
-     "        // c1\n"
-     "        // c2\n"
-     "        arg2\n"
-     "        // c1\n"
-     "        // c2\n"
-     "    )\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"
-     "// c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */\n"
-     "/* c2 */(/* c1 */\n"
-     "/* c2 */arg1/* c1 */\n"
-     "/* c2 */,/* c1 */\n"
-     "/* c2 */arg2/* c1 */\n"
-     "/* c2 */)/* c1 */\n"
-     "/* c2 */;/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */ (  /* c1 */\n"
-     "        /* c2 */ arg1  /* c1 */\n"
-     "        /* c2 */,  /* c1 */\n"
-     "        /* c2 */ arg2  /* c1 */\n"
-     "    /* c2 */)  /* c1 */\n"
-     "/* c2 */;  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz// c1\n"
-     "/* c2 */(// c1\n"
-     "/* c2 */arg1// c1\n"
-     "/* c2 */,// c1\n"
-     "/* c2 */arg2// c1\n"
-     "/* c2 */)// c1\n"
-     "/* c2 */;// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    /* c2 */ (  // c1\n"
-     "        /* c2 */ arg1  // c1\n"
-     "        /* c2 */,  // c1\n"
-     "        /* c2 */ arg2  // c1\n"
-     "    /* c2 */)  // c1\n"
-     "/* c2 */;  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */arg1/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */,/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */arg2/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */)/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */ (  /* c1 */\n"
-     "        /* c2 */\n"
-     "        /* c3 */ arg1  /* c1 */\n"
-     "        /* c2 */\n"
-     "        /* c3 */,  /* c1 */\n"
-     "        /* c2 */\n"
-     "        /* c3 */ arg2  /* c1 */\n"
-     "        /* c2 */\n"
-     "    /* c3 */)  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */\n"
-     "/* c2 */\n"
-     "(/* c1 */\n"
-     "/* c2 */\n"
-     "arg1/* c1 */\n"
-     "/* c2 */\n"
-     ",/* c1 */\n"
-     "/* c2 */\n"
-     "arg2/* c1 */\n"
-     "/* c2 */\n"
-     ")/* c1 */\n"
-     "/* c2 */\n"
-     ";/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    (  /* c1 */\n"
-     "        /* c2 */\n"
-     "        arg1  /* c1 */\n"
-     "        /* c2 */\n"
-     "        ,  /* c1 */\n"
-     "        /* c2 */\n"
-     "        arg2  /* c1 */\n"
-     "        /* c2 */\n"
-     "    )  /* c1 */\n"
-     "/* c2 */\n"
-     ";  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz// c1\n"
-     "/* c2 */\n"
-     "(// c1\n"
-     "/* c2 */\n"
-     "arg1// c1\n"
-     "/* c2 */\n"
-     ",// c1\n"
-     "/* c2 */\n"
-     "arg2// c1\n"
-     "/* c2 */\n"
-     ")// c1\n"
-     "/* c2 */\n"
-     ";// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    /* c2 */\n"
-     "    (  // c1\n"
-     "        /* c2 */\n"
-     "        arg1  // c1\n"
-     "        /* c2 */\n"
-     "        ,  // c1\n"
-     "        /* c2 */\n"
-     "        arg2  // c1\n"
-     "        /* c2 */\n"
-     "    )  // c1\n"
-     "/* c2 */\n"
-     ";  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */\n"
-     "// c2\n"
-     "(/* c1 */\n"
-     "// c2\n"
-     "arg1/* c1 */\n"
-     "// c2\n"
-     ",/* c1 */\n"
-     "// c2\n"
-     "arg2/* c1 */\n"
-     "// c2\n"
-     ")/* c1 */\n"
-     "// c2\n"
-     ";/* c1 */\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    // c2\n"
-     "    (  /* c1 */\n"
-     "        // c2\n"
-     "        arg1  /* c1 */\n"
-     "        // c2\n"
-     "        ,  /* c1 */\n"
-     "        // c2\n"
-     "        arg2  /* c1 */\n"
-     "        // c2\n"
-     "    )  /* c1 */\n"
-     "// c2\n"
-     ";  /* c1 */\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz// c1\n"
-     "// c2\n"
-     "(// c1\n"
-     "// c2\n"
-     "arg1// c1\n"
-     "// c2\n"
-     ",// c1\n"
-     "// c2\n"
-     "arg2// c1\n"
-     "// c2\n"
-     ")// c1\n"
-     "// c2\n"
-     ";// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    // c2\n"
-     "    (  // c1\n"
-     "       // c2\n"
-     "        arg1  // c1\n"
-     "        // c2\n"
-     "        ,  // c1\n"
-     "           // c2\n"
-     "        arg2  // c1\n"
-     "        // c2\n"
-     "    )  // c1\n"
-     "       // c2\n"
-     ";  // c1\n"
-     "   // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "arg1/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ",/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "arg2/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ")/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     "    (  /* c1 */\n"
-     "        /* c2 */\n"
-     "        /* c3 */\n"
-     "        arg1  /* c1 */\n"
-     "        /* c2 */\n"
-     "        /* c3 */\n"
-     "        ,  /* c1 */\n"
-     "        /* c2 */\n"
-     "        /* c3 */\n"
-     "        arg2  /* c1 */\n"
-     "        /* c2 */\n"
-     "        /* c3 */\n"
-     "    )  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz// c1\n"
-     "// c2\n"
-     "// c3\n"
-     "(// c1\n"
-     "// c2\n"
-     "// c3\n"
-     "arg1// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ",// c1\n"
-     "// c2\n"
-     "// c3\n"
-     "arg2// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ")// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";// c1\n"
-     "// c2\n"
-     "// c3\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "$foobarbaz  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     "    (  // c1\n"
-     "       // c2\n"
-     "       // c3\n"
-     "        arg1  // c1\n"
-     "        // c2\n"
-     "        // c3\n"
-     "        ,  // c1\n"
-     "           // c2\n"
-     "           // c3\n"
-     "        arg2  // c1\n"
-     "        // c2\n"
-     "        // c3\n"
-     "    )  // c1\n"
-     "       // c2\n"
-     "       // c3\n"
-     ";  // c1\n"
-     "   // c2\n"
-     "   // c3\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c */arg1/* c */,/* c */arg2/* c */)/* c */;/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c */\n"
-     "    arg1  /* c */,  /* c */\n"
-     "    arg2  /* c */)  /* c */;  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ /* c2 */arg1/* c1 */ /* c2 */,/* c1 */ /* c2 "
-     "*/arg2/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  /* c2 */\n"
-     "    arg1  /* c1 */  /* c2 */,  /* c1 */  /* c2 */\n"
-     "    arg2  /* c1 */  /* c2 */)  /* c1 */  /* c2 */;  /* c1 */  /* c2 "
-     "*/\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c */\n"
-     "arg1/* c */\n"
-     ",/* c */\n"
-     "arg2/* c */\n"
-     ")/* c */\n"
-     ";/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c */\n"
-     "    arg1  /* c */\n"
-     "    ,  /* c */\n"
-     "    arg2  /* c */\n"
-     ")  /* c */\n"
-     ";  /* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ /* c2 */\n"
-     "arg1/* c1 */ /* c2 */\n"
-     ",/* c1 */ /* c2 */\n"
-     "arg2/* c1 */ /* c2 */\n"
-     ")/* c1 */ /* c2 */\n"
-     ";/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  /* c2 */\n"
-     "    arg1  /* c1 */  /* c2 */\n"
-     "    ,  /* c1 */  /* c2 */\n"
-     "    arg2  /* c1 */  /* c2 */\n"
-     ")  /* c1 */  /* c2 */\n"
-     ";  /* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c\n"
-     "arg1// c\n"
-     ",// c\n"
-     "arg2// c\n"
-     ")// c\n"
-     ";// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c\n"
-     "    arg1  // c\n"
-     "    ,  // c\n"
-     "    arg2  // c\n"
-     ")  // c\n"
-     ";  // c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */ // c2\n"
-     "arg1/* c1 */ // c2\n"
-     ",/* c1 */ // c2\n"
-     "arg2/* c1 */ // c2\n"
-     ")/* c1 */ // c2\n"
-     ";/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */  // c2\n"
-     "    arg1  /* c1 */  // c2\n"
-     "    ,  /* c1 */  // c2\n"
-     "    arg2  /* c1 */  // c2\n"
-     ")  /* c1 */  // c2\n"
-     ";  /* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c */arg1\n"
-     "/* c */,\n"
-     "/* c */arg2\n"
-     "/* c */)\n"
-     "/* c */;\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c */ arg1\n"
-     "    /* c */,\n"
-     "    /* c */ arg2\n"
-     "/* c */)\n"
-     "/* c */;\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ /* c2 */arg1\n"
-     "/* c1 */ /* c2 */,\n"
-     "/* c1 */ /* c2 */arg2\n"
-     "/* c1 */ /* c2 */)\n"
-     "/* c1 */ /* c2 */;\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */  /* c2 */ arg1\n"
-     "    /* c1 */  /* c2 */,\n"
-     "    /* c1 */  /* c2 */ arg2\n"
-     "/* c1 */  /* c2 */)\n"
-     "/* c1 */  /* c2 */;\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c */\n"
-     "arg1\n"
-     "/* c */\n"
-     ",\n"
-     "/* c */\n"
-     "arg2\n"
-     "/* c */\n"
-     ")\n"
-     "/* c */\n"
-     ";\n"
-     "/* c */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c */\n"
-     "    arg1\n"
-     "    /* c */\n"
-     "    ,\n"
-     "    /* c */\n"
-     "    arg2\n"
-     "    /* c */\n"
-     ")\n"
-     "/* c */\n"
-     ";\n"
-     "/* c */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ /* c2 */\n"
-     "arg1\n"
-     "/* c1 */ /* c2 */\n"
-     ",\n"
-     "/* c1 */ /* c2 */\n"
-     "arg2\n"
-     "/* c1 */ /* c2 */\n"
-     ")\n"
-     "/* c1 */ /* c2 */\n"
-     ";\n"
-     "/* c1 */ /* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */  /* c2 */\n"
-     "    arg1\n"
-     "    /* c1 */  /* c2 */\n"
-     "    ,\n"
-     "    /* c1 */  /* c2 */\n"
-     "    arg2\n"
-     "    /* c1 */  /* c2 */\n"
-     ")\n"
-     "/* c1 */  /* c2 */\n"
-     ";\n"
-     "/* c1 */  /* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "// c\n"
-     "arg1\n"
-     "// c\n"
-     ",\n"
-     "// c\n"
-     "arg2\n"
-     "// c\n"
-     ")\n"
-     "// c\n"
-     ";\n"
-     "// c\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    // c\n"
-     "    arg1\n"
-     "    // c\n"
-     "    ,\n"
-     "    // c\n"
-     "    arg2\n"
-     "    // c\n"
-     ")\n"
-     "// c\n"
-     ";\n"
-     "// c\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */ // c2\n"
-     "arg1\n"
-     "/* c1 */ // c2\n"
-     ",\n"
-     "/* c1 */ // c2\n"
-     "arg2\n"
-     "/* c1 */ // c2\n"
-     ")\n"
-     "/* c1 */ // c2\n"
-     ";\n"
-     "/* c1 */ // c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */  // c2\n"
-     "    arg1\n"
-     "    /* c1 */  // c2\n"
-     "    ,\n"
-     "    /* c1 */  // c2\n"
-     "    arg2\n"
-     "    /* c1 */  // c2\n"
-     ")\n"
-     "/* c1 */  // c2\n"
-     ";\n"
-     "/* c1 */  // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "arg1\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ",\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     "arg2\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ")\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"
-     "/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     "    arg1\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     "    ,\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     "    arg2\n"
-     "    /* c1 */\n"
-     "    /* c2 */\n"
-     ")\n"
-     "/* c1 */\n"
-     "/* c2 */\n"
-     ";\n"
-     "/* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "// c1\n"
-     "// c2\n"
-     "arg1\n"
-     "// c1\n"
-     "// c2\n"
-     ",\n"
-     "// c1\n"
-     "// c2\n"
-     "arg2\n"
-     "// c1\n"
-     "// c2\n"
-     ")\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"
-     "// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(\n"
-     "    // c1\n"
-     "    // c2\n"
-     "    arg1\n"
-     "    // c1\n"
-     "    // c2\n"
-     "    ,\n"
-     "    // c1\n"
-     "    // c2\n"
-     "    arg2\n"
-     "    // c1\n"
-     "    // c2\n"
-     ")\n"
-     "// c1\n"
-     "// c2\n"
-     ";\n"
-     "// c1\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */arg1/* c1 */\n"
-     "/* c2 */,/* c1 */\n"
-     "/* c2 */arg2/* c1 */\n"
-     "/* c2 */)/* c1 */\n"
-     "/* c2 */;/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */ arg1  /* c1 */\n"
-     "    /* c2 */,  /* c1 */\n"
-     "    /* c2 */ arg2  /* c1 */\n"
-     "/* c2 */)  /* c1 */\n"
-     "/* c2 */;  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "/* c2 */arg1// c1\n"
-     "/* c2 */,// c1\n"
-     "/* c2 */arg2// c1\n"
-     "/* c2 */)// c1\n"
-     "/* c2 */;// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    /* c2 */ arg1  // c1\n"
-     "    /* c2 */,  // c1\n"
-     "    /* c2 */ arg2  // c1\n"
-     "/* c2 */)  // c1\n"
-     "/* c2 */;  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */arg1/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */,/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */arg2/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */)/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */ arg1  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */,  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */ arg2  /* c1 */\n"
-     "    /* c2 */\n"
-     "/* c3 */)  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */;  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     "arg1/* c1 */\n"
-     "/* c2 */\n"
-     ",/* c1 */\n"
-     "/* c2 */\n"
-     "arg2/* c1 */\n"
-     "/* c2 */\n"
-     ")/* c1 */\n"
-     "/* c2 */\n"
-     ";/* c1 */\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    arg1  /* c1 */\n"
-     "    /* c2 */\n"
-     "    ,  /* c1 */\n"
-     "    /* c2 */\n"
-     "    arg2  /* c1 */\n"
-     "    /* c2 */\n"
-     ")  /* c1 */\n"
-     "/* c2 */\n"
-     ";  /* c1 */\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "/* c2 */\n"
-     "arg1// c1\n"
-     "/* c2 */\n"
-     ",// c1\n"
-     "/* c2 */\n"
-     "arg2// c1\n"
-     "/* c2 */\n"
-     ")// c1\n"
-     "/* c2 */\n"
-     ";// c1\n"
-     "/* c2 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    /* c2 */\n"
-     "    arg1  // c1\n"
-     "    /* c2 */\n"
-     "    ,  // c1\n"
-     "    /* c2 */\n"
-     "    arg2  // c1\n"
-     "    /* c2 */\n"
-     ")  // c1\n"
-     "/* c2 */\n"
-     ";  // c1\n"
-     "/* c2 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "// c2\n"
-     "arg1/* c1 */\n"
-     "// c2\n"
-     ",/* c1 */\n"
-     "// c2\n"
-     "arg2/* c1 */\n"
-     "// c2\n"
-     ")/* c1 */\n"
-     "// c2\n"
-     ";/* c1 */\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    // c2\n"
-     "    arg1  /* c1 */\n"
-     "    // c2\n"
-     "    ,  /* c1 */\n"
-     "    // c2\n"
-     "    arg2  /* c1 */\n"
-     "    // c2\n"
-     ")  /* c1 */\n"
-     "// c2\n"
-     ";  /* c1 */\n"
-     "// c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "// c2\n"
-     "arg1// c1\n"
-     "// c2\n"
-     ",// c1\n"
-     "// c2\n"
-     "arg2// c1\n"
-     "// c2\n"
-     ")// c1\n"
-     "// c2\n"
-     ";// c1\n"
-     "// c2\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    // c2\n"
-     "    arg1  // c1\n"
-     "    // c2\n"
-     "    ,  // c1\n"
-     "       // c2\n"
-     "    arg2  // c1\n"
-     "    // c2\n"
-     ")  // c1\n"
-     "   // c2\n"
-     ";  // c1\n"
-     "   // c2\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "arg1/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ",/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     "arg2/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ")/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";/* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     "    arg1  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     "    ,  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     "    arg2  /* c1 */\n"
-     "    /* c2 */\n"
-     "    /* c3 */\n"
-     ")  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"
-     ";  /* c1 */\n"
-     "/* c2 */\n"
-     "/* c3 */\n"},
-    {"// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(// c1\n"
-     "// c2\n"
-     "// c3\n"
-     "arg1// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ",// c1\n"
-     "// c2\n"
-     "// c3\n"
-     "arg2// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ")// c1\n"
-     "// c2\n"
-     "// c3\n"
-     ";// c1\n"
-     "// c2\n"
-     "// c3\n",
-     "// verilog_syntax: parse-as-module-body\n"
-     "`FOOBARBAZ(  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     "    arg1  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     "    ,  // c1\n"
-     "       // c2\n"
-     "       // c3\n"
-     "    arg2  // c1\n"
-     "    // c2\n"
-     "    // c3\n"
-     ")  // c1\n"
-     "   // c2\n"
-     "   // c3\n"
-     ";  // c1\n"
-     "   // c2\n"
-     "   // c3\n"},
-    {"module indent();\n"
-     "   reg     a;\n"
-     "   reg [32:0] b;\n"
-     "   wire    c;\n"
-     "   wire    d = e ? kFoo : kBar;\n"
-     "endmodule\n",
-     "module indent ();\n"
-     "  reg         a;\n"
-     "  reg  [32:0] b;\n"
-     "  wire        c;\n"
-     "  wire        d = e ? kFoo : kBar;\n"
-     "endmodule\n"},
-
-    {"class C; T1 b; logic [$] a; T1 [$] c; endclass\n",
-     "class C;\n"
-     "  T1        b;\n"
-     "  logic [$] a;\n"
-     "  T1    [$] c;\n"
-     "endclass\n"},
-    {"class C;\n"
-     "  T1 b; //test\n"
-     "  logic [$] a; //test\n"
-     "  T1    [$] c; //test\n"
-     "endclass\n",
-     "class C;\n"
-     "  T1        b;  //test\n"
-     "  logic [$] a;  //test\n"
-     "  T1    [$] c;  //test\n"
-     "endclass\n"},
-    {"class C;\n"
-     "  T1\n"
-     "  b;\n"
-     "  logic\n"
-     "  [$]\n"
-     "  a;\n"
-     "  T1\n"
-     "  [$]\n"
-     "  c;\n"
-     "endclass\n",
-     "class C;\n"
-     "  T1        b;\n"
-     "  logic [$] a;\n"
-     "  T1    [$] c;\n"
-     "endclass\n"},
-    {"class C;\n"
-     "  logic/*t*/ [0 : 1] /*t*/\n"
-     "  a;/*t*/\n"
-     "  T1/*t*/[0 : 1]/*t*/\n"
-     "  c;/*t*/\n"
-     "endclass\n",
-     "class C;\n"
-     "  logic/*t*/ [0 : 1]  /*t*/ a;  /*t*/\n"
-     "  T1/*t*/    [0 : 1]  /*t*/ c;  /*t*/\n"
-     "endclass\n"},
-    {"always @(*/*t*/) begin\n"
-     "end\n",
-     "always @(*  /*t*/) begin\n"
-     "end\n"},
-    {"always @(/*t*/*) begin\n"
-     "end\n",
-     "always @(  /*t*/ *) begin\n"
-     "end\n"},
-    {"always @(/*t*/*/*t*/) begin\n"
-     "end\n",
-     "always @(  /*t*/ *  /*t*/) begin\n"
-     "end\n"},
-    {"always @(*) begin\n"
-     "end\n",
-     "always @(*) begin\n"
-     "end\n"},
-    {"always @(* ) begin\n"
-     "end\n",
-     "always @(*) begin\n"
-     "end\n"},
-    {"always @( *) begin\n"
-     "end\n",
-     "always @(*) begin\n"
-     "end\n"},
-    {"always @( * ) begin\n"
-     "end\n",
-     "always @(*) begin\n"
-     "end\n"},
-    {"always @(  /*t*/  *   /*t*/    ) begin\n"
-     "end\n",
-     "always @(  /*t*/ *  /*t*/) begin\n"
-     "end\n"},
-    {
-        // Don't touch verilog_format:off region #1538
-        R"(
-module testcode;
-  // verilog_format: off
-  assign a = b
-           & c;
-  // verilog_format: on
-      assign e = d;
-endmodule
-)",
-        R"(
-module testcode;
-  // verilog_format: off
-  assign a = b
-           & c;
-  // verilog_format: on
-  assign e = d;
-endmodule
-)",
-
-    },
-
-    // -----------------------------------------------------------------
 };
 
-// Tests that formatter produces expected results, end-to-end.
-TEST(FormatterEndToEndTest, VerilogFormatTest) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  for (const auto &test_case : kFormatterTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, AutoInferAlignment) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {"", ""},
-      {"\n", "\n"},
-      {"class  cc ;\n"
-       "endclass:cc\n",
-       "class cc;\n"
-       "endclass : cc\n"},
-
-      // module port declarations
-      {"module pd(\n"
-       "input wire foo,\n"
-       "output reg bar\n"
-       ");\n"
-       "endmodule:pd\n",
-       "module pd (\n"
-       "    input  wire foo,\n"  // flush-left vs. align are similar enough,
-       "    output reg  bar\n"   // so automatic policy will align.
-       ");\n"
-       "endmodule : pd\n"},
-      {"module pd(\n"
-       "input  foo_pkg::baz_t foo,\n"
-       "output reg  bar\n"
-       ");\n"
-       "endmodule:pd\n",
-       "module pd (\n"
-       "    input foo_pkg::baz_t foo,\n"  // alignment would add too many spaces
-       "    output reg bar\n"             // so infer intent to flush-left.
-       ");\n"
-       "endmodule : pd\n"},
-      {"module pd(\n"
-       "input  foo_pkg::baz_t foo,\n"
-       "output     reg  bar\n"  // user injects 4 excess spaces here ...
-       ");\n"
-       "endmodule:pd\n",
-       "module pd (\n"
-       "    input  foo_pkg::baz_t foo,\n"
-       "    output reg            bar\n"  // ... and triggers alignment.
-       ");\n"
-       "endmodule : pd\n"},
-      {"module pd(\n"
-       "`ifdef FAA\n"  // inside preprocessing conditional
-       "input  baaaz_t foo,\n"
-       "output reg      bar\n"  // user injects 4 excess spaces here ...
-       "`endif\n"
-       ");\n"
-       "endmodule:pd\n",
-       "module pd (\n"
-       "`ifdef FAA\n"
-       "    input  baaaz_t foo,\n"
-       "    output reg     bar\n"  // ... and triggers alignment.
-       "`endif\n"
-       ");\n"
-       "endmodule : pd\n"},
-      {"module pd(\n"
-       "`ifdef FAA\n"  // inside preprocessing conditional
-       "input  baaaz_t foo,\n"
-       "`else\n"
-       "output reg      bar\n"  // user injects 4 excess spaces here ...
-       "`endif\n"
-       ");\n"
-       "endmodule:pd\n",
-       "module pd (\n"
-       "`ifdef FAA\n"
-       "    input  baaaz_t foo,\n"  // aligned
-       "`else\n"                    // aligned across preprocessing directives
-       "    output reg     bar\n"   // ... and triggers alignment.
-       "`endif\n"
-       ");\n"
-       "endmodule : pd\n"},
-      {"module pd(\n"
-       "input logic [31:0] bus,\n"
-       "input logic [7:0] bus2,\n"
-       "`ifdef FAA\n"  // inside preprocessing conditional
-       "input  baaaz_t foo,\n"
-       "`else\n"
-       "output reg      bar,\n"  // user injects 4 excess spaces here ...
-       "`endif\n"
-       "output out_t zout1,\n"
-       "output out_t zout2\n"
-       ");\n"
-       "endmodule:pd\n",
-       "module pd (\n"
-       "    input  logic   [31:0] bus,\n"  // treated as one large group
-       "    input  logic   [ 7:0] bus2,\n"
-       "`ifdef FAA\n"
-       "    input  baaaz_t        foo,\n"  // aligned
-       "`else\n"  // aligned across preprocessing directives
-       "    output reg            bar,\n"  // ... and triggers alignment.
-       "`endif\n"
-       "    output out_t          zout1,\n"
-       "    output out_t          zout2\n"
-       ");\n"
-       "endmodule : pd\n"},
-      {"module pd(\n"
-       "input logic [7:0] bus2,\n"
-       "`ifndef FAA\n"  // inside preprocessing conditional
-       "input logic [31:0] bus,\n"
-       "input  baaaz_t foo,\n"
-       "`elsif BLA\n"
-       "output reg      bar,\n"  // user injects 4 excess spaces here ...
-       "output out_t zout1,\n"
-       "`endif\n"
-       "output out_t zout2\n"
-       ");\n"
-       "endmodule:pd\n",
-       "module pd (\n"
-       "    input  logic   [ 7:0] bus2,\n"
-       "`ifndef FAA\n"
-       "    input  logic   [31:0] bus,\n"  // treated as one large group
-       "    input  baaaz_t        foo,\n"  // aligned
-       "`elsif BLA\n"  // aligned across preprocessing directives
-       "    output reg            bar,\n"  // ... and triggers alignment.
-       "    output out_t          zout1,\n"
-       "`endif\n"
-       "    output out_t          zout2\n"
-       ");\n"
-       "endmodule : pd\n"},
-      {// data declaration and net declaration in ports
-       "module m(\n"
-       "logic [x:y]a    ,\n"    // packed dimensions, induce alignment
-       "wire [pp:qq] [e:f]b\n"  // packed dimensions, 2D
-       ") ;\n"
-       "endmodule\n",
-       "module m (\n"
-       "    logic [  x:y]      a,\n"
-       "    wire  [pp:qq][e:f] b\n"
-       ");\n"
-       "endmodule\n"},
-      {// used-defined data declarations in ports
-       "module m(\n"
-       "a::bb [x:y]a    ,\n"       // packed dimensions, induce alignment
-       "c#(d,e) [pp:qq] [e:f]b\n"  // packed dimensions, 2D
-       ") ;\n"
-       "endmodule\n",
-       "module m (\n"
-       "    a::bb    [  x:y]      a,\n"
-       "    c#(d, e) [pp:qq][e:f] b\n"
-       ");\n"
-       "endmodule\n"},
-
-      // named parameter arguments
-      {"module  mm ;\n"
-       "foo #(\n"
-       ".a(a),\n"
-       ".bb(bb)\n"
-       ")bar( );\n"
-       "endmodule:mm\n",
-       "module mm;\n"
-       "  foo #(\n"
-       "      .a (a),\n"  // align doesn't add too many spaces, so align
-       "      .bb(bb)\n"
-       "  ) bar ();\n"
-       "endmodule : mm\n"},
-      {"module  mm ;\n"
-       "foo #(\n"
-       ".a(a),\n"
-       ".bbcccc(bb)\n"
-       ")bar( );\n"
-       "endmodule:mm\n",
-       "module mm;\n"
-       "  foo #(\n"
-       "      .a(a),\n"  // align would add too many spaces, so flush-left
-       "      .bbcccc(bb)\n"
-       "  ) bar ();\n"
-       "endmodule : mm\n"},
-      {"module  mm ;\n"
-       "foo #(\n"
-       ".a(a    ),\n"  // user manually triggers alignment with excess spaces
-       ".bbcccc(bb)\n"
-       ")bar( );\n"
-       "endmodule:mm\n",
-       "module mm;\n"
-       "  foo #(\n"
-       "      .a     (a),\n"  // induced alignment
-       "      .bbcccc(bb)\n"
-       "  ) bar ();\n"
-       "endmodule : mm\n"},
-      {"module  mm ;\n"
-       "foo #(\n"
-       "//c1\n"        // with comments (indented but not aligned)
-       ".a(a    ),\n"  // user manually triggers alignment with excess spaces
-       "//c2\n"
-       ".bbcccc(bb)\n"
-       "//c3\n"
-       ")bar( );\n"
-       "endmodule:mm\n",
-       "module mm;\n"
-       "  foo #(\n"
-       "      //c1\n"
-       "      .a     (a),\n"  // induced alignment
-       "      //c2\n"
-       "      .bbcccc(bb)\n"
-       "      //c3\n"
-       "  ) bar ();\n"
-       "endmodule : mm\n"},
-      {"module  mm ;\n"
-       "foo #(\n"
-       ".a( (1     +2)),\n"  // excess spaces, testing extra parentheses
-       ".bbcccc((c*d)+(e*f))\n"
-       ")bar( );\n"
-       "endmodule:mm\n",
-       "module mm;\n"
-       "  foo #(\n"
-       "      .a     ((1 + 2)),\n"  // induced alignment
-       "      .bbcccc((c * d) + (e * f))\n"
-       "  ) bar ();\n"
-       "endmodule : mm\n"},
-
-      // named port connections
-      {"module  mm ;\n"
-       "foo bar(\n"
-       ".a(a),\n"
-       ".bb(bb)\n"
-       ");\n"
-       "endmodule:mm\n",
-       "module mm;\n"
-       "  foo bar (\n"
-       "      .a (a),\n"  // align doesn't add too many spaces, so align
-       "      .bb(bb)\n"
-       "  );\n"
-       "endmodule : mm\n"},
-      {"module  mm ;\n"
-       "foo bar(\n"
-       ".a(a),\n"
-       ".bbbbbb(bb)\n"
-       ");\n"
-       "endmodule:mm\n",
-       "module mm;\n"
-       "  foo bar (\n"
-       "      .a(a),\n"  // align would add too many spaces, so flush-left
-       "      .bbbbbb(bb)\n"
-       "  );\n"
-       "endmodule : mm\n"},
-      {"module  mm ;\n"
-       "foo bar(\n"
-       ".a    (a),\n"  // user manually triggers alignment with excess spaces
-       ".bbbbbb(bb)\n"
-       ");\n"
-       "endmodule:mm\n",
-       "module mm;\n"
-       "  foo bar (\n"
-       "      .a     (a),\n"  // alignment fixed
-       "      .bbbbbb(bb)\n"
-       "  );\n"
-       "endmodule : mm\n"},
-
-      // net variable declarations
-      {"module nn;\n"
-       "wire wwwww;\n"
-       "logic lll;\n"
-       "endmodule : nn\n",
-       "module nn;\n"
-       "  wire  wwwww;\n"  // alignment adds few spaces, so align
-       "  logic lll;\n"
-       "endmodule : nn\n"},
-      {"module nn;\n"
-       "wire wwwww;\n"
-       "foo_pkg::baz_t lll;\n"
-       "endmodule : nn\n",
-       "module nn;\n"
-       "  wire wwwww;\n"  // alignment adds too many spaces, so flush-left
-       "  foo_pkg::baz_t lll;\n"
-       "endmodule : nn\n"},
-      {"module nn;\n"
-       "wire     wwwww;\n"  // user injects spaces to trigger alignment
-       "foo_pkg::baz_t lll;\n"
-       "endmodule : nn\n",
-       "module nn;\n"
-       "  wire           wwwww;\n"  // ... and gets alignment
-       "  foo_pkg::baz_t lll;\n"
-       "endmodule : nn\n"},
-      {// data/net declarations as generate items (conditional)
-       "module nn;\n"
-       "if (cc)begin:fff\n"
-       "wire wwwww;\n"
-       "logic lll;\n"
-       "end:fff\n"
-       "endmodule : nn\n",
-       "module nn;\n"
-       "  if (cc) begin : fff\n"
-       "    wire  wwwww;\n"  // alignment adds few spaces, so align
-       "    logic lll;\n"
-       "  end : fff\n"
-       "endmodule : nn\n"},
-
-      // continuous assignments
-      {"module m_assign;\n"
-       "assign foo = 1'b1;\n"  // alignment adds few spaces, so align
-       "assign baar = 1'b0;\n"
-       "endmodule\n",
-       "module m_assign;\n"
-       "  assign foo  = 1'b1;\n"  // aligned
-       "  assign baar = 1'b0;\n"
-       "endmodule\n"},
-      {"module m_assign;\n"
-       "assign foo  =  1'b1;\n"  // alignment adds too many spaces, so
-                                 // flush-left
-       "assign baaaaaar = 1'b0;\n"
-       "endmodule\n",
-       "module m_assign;\n"
-       "  assign foo = 1'b1;\n"  // flush-left
-       "  assign baaaaaar = 1'b0;\n"
-       "endmodule\n"},
-      {"module m_assign;\n"
-       "assign foo  =     1'b1;\n"  // induce alignment with excess spaces
-       "assign baaaaaar = 1'b0;\n"
-       "endmodule\n",
-       "module m_assign;\n"
-       "  assign foo      = 1'b1;\n"  // aligned
-       "  assign baaaaaar = 1'b0;\n"
-       "endmodule\n"},
-      {// currently, does not assign across ifdefs
-       "module m_assign;\n"
-       "`ifdef FOO\n"
-       "assign foo  =     1'b1;\n"  // induce alignment with excess spaces
-       "assign baaaaaar = 1'b0;\n"
-       "`else\n"
-       "assign zooo = 2'b11;\n"
-       "assign yoo = 2'b00;\n"
-       "`endif\n"
-       "endmodule\n",
-       "module m_assign;\n"
-       "`ifdef FOO\n"
-       "  assign foo      = 1'b1;\n"  // aligned
-       "  assign baaaaaar = 1'b0;\n"
-       "`else\n"                   // aligned separately above/below
-       "  assign zooo = 2'b11;\n"  // aligned
-       "  assign yoo  = 2'b00;\n"  // aligned
-       "`endif\n"
-       "endmodule\n"},
-      {// mixed net declaration and continuous assignment, both groups aligned
-       "module m_assign;\n"
-       "wire     wwwww;\n"  // induce alignment
-       "foo_pkg::baz_t lll;\n"
-       "assign foo  =     1'b1;\n"  // induce alignment
-       "assign baaaaaar = 1'b0;\n"
-       "endmodule\n",
-       "module m_assign;\n"
-       "  wire           wwwww;\n"  // aligned
-       "  foo_pkg::baz_t lll;\n"
-       "  assign foo      = 1'b1;\n"  // aligned
-       "  assign baaaaaar = 1'b0;\n"
-       "endmodule\n"},
-      {// continuous assignments as generate items (conditional)
-       "module m_assign;\n"
-       "if (xy) begin\n"
-       "assign foo  =  1'b0;\n"  // align: adds few spaces
-       "assign baaar = 1'b1;\n"
-       "end else begin\n"
-       "assign goo  =      1'b1;\n"  // induce alignment with excess spaces
-       "assign zaaaaaar = 1'b0;\n"
-       "end\n"
-       "endmodule\n",
-       "module m_assign;\n"
-       "  if (xy) begin\n"
-       "    assign foo   = 1'b0;\n"  // aligned
-       "    assign baaar = 1'b1;\n"
-       "  end else begin\n"
-       "    assign goo      = 1'b1;\n"  // induce alignment with excess spaces
-       "    assign zaaaaaar = 1'b0;\n"
-       "  end\n"
-       "endmodule\n"},
-      {// continuous assignments as generate items (loop)
-       "module m_assign;\n"
-       "for(genvar i=0; i<k; ++i ) begin\n"
-       "assign foo  =  1'b0;\n"  // align: adds few spaces
-       "assign baaar = 1'b1;\n"
-       "end\n"
-       "endmodule\n",
-       "module m_assign;\n"
-       "  for (genvar i = 0; i < k; ++i) begin\n"
-       "    assign foo   = 1'b0;\n"  // aligned
-       "    assign baaar = 1'b1;\n"
-       "  end\n"
-       "endmodule\n"},
-      {// continuous assignments as generate items (case)
-       "module m_assign;\n"
-       "case (c)\n"
-       "jk:begin\n"
-       "assign foo  =  1'b0;\n"  // align: adds few spaces
-       "assign baaar = 1'b1;\n"
-       "end\n"
-       "endcase\n"
-       "endmodule\n",
-       "module m_assign;\n"
-       "  case (c)\n"
-       "    jk: begin\n"
-       "      assign foo   = 1'b0;\n"  // aligned
-       "      assign baaar = 1'b1;\n"
-       "    end\n"
-       "  endcase\n"
-       "endmodule\n"},
-      {// continuous assignment with comment
-       "module m;\n"
-       "// comment1\n"
-       "assign aaaaa = (bbbbb != ccccc) &\n"
-       "// comment2\n"
-       "(ddddd | (eeeee & ffffff));\n"
-       "endmodule\n",
-       "module m;\n"
-       "  // comment1\n"
-       "  assign aaaaa = (bbbbb != ccccc) &\n"
-       "      // comment2\n"
-       "      (ddddd | (eeeee & ffffff));\n"
-       "endmodule\n"},
-
-      // net/variable assignments: blocking and nonblocking
-      {"module  ma ;\n"
-       "initial  begin\n"
-       "aa = b;\n"
-       "c = 1'b0;\n"
-       "end\n"
-       "endmodule\n",
-       "module ma;\n"
-       "  initial begin\n"
-       "    aa = b;\n"
-       "    c  = 1'b0;\n"  // only one space to align
-       "  end\n"
-       "endmodule\n"},
-      {"function void  fa ;\n"
-       "c = 1'b0;\n"
-       "aa = b;\n"
-       "endfunction\n",
-       "function void fa;\n"
-       "  c  = 1'b0;\n"  // only one space to align
-       "  aa = b;\n"
-       "endfunction\n"},
-      {"task  ta ; \n"
-       "aa =  b;\n"
-       "c = 1'b0;\n"
-       "endtask\n",
-       "task ta;\n"
-       "  aa = b;\n"
-       "  c  = 1'b0;\n"  // only one space to align
-       "endtask\n"},
-      {"module  ma ;\n"
-       "always@( posedge clk) begin\n"
-       "aaa <= b;\n"
-       "c <= 1'b0;\n"
-       "end\n"
-       "endmodule\n",
-       "module ma;\n"
-       "  always @(posedge clk) begin\n"
-       "    aaa <= b;\n"
-       "    c   <= 1'b0;\n"  // only two spaces to align
-       "  end\n"
-       "endmodule\n"},
-      {"function int  fa ;\n"
-       "c <= 1'b0;\n"
-       "aa <= b;\n"
-       "return 0 ;\n"
-       "endfunction\n",
-       "function int fa;\n"
-       "  c  <= 1'b0;\n"  // only one space to align
-       "  aa <= b;\n"
-       "  return 0;\n"
-       "endfunction\n"},
-      {"task  ta ; \n"
-       "$display (\"hello\" );\n"
-       "aa <=  b;\n"
-       "c <= 1'b0;\n"
-       "endtask\n",
-       "task ta;\n"
-       "  $display(\"hello\");\n"
-       "  aa <= b;\n"
-       "  c  <= 1'b0;\n"  // only one space to align
-       "endtask\n"},
-      {// mixed blocking and nonblocking assignments
-       "module  ma ;\n"
-       "always@( posedge clk) begin\n"
-       "aaaaa  = b;\n"
-       "ccc  = 1'b0;\n"
-       "aaa <= b;\n"
-       "c <= 1'b0;\n"
-       "end\n"
-       "endmodule\n",
-       "module ma;\n"
-       "  always @(posedge clk) begin\n"
-       "    aaaaa = b;\n"
-       "    ccc   = 1'b0;\n"  // only two spaces to align
-       "    aaa <= b;\n"
-       "    c   <= 1'b0;\n"  // only two spaces to align (separate group)
-       "  end\n"
-       "endmodule\n"},
-      {"task  ta ; \n"
-       "aa <=  b;\n"
-       "c <= 1'b0;\n"
-       "$display (\"hello\" );\n"  // separates above/below alignment groups
-       "zzaa <=  b;\n"
-       "zzc <= 1'b0;\n"
-       "endtask\n",
-       "task ta;\n"
-       "  aa <= b;\n"
-       "  c  <= 1'b0;\n"  // only one space to align
-       "  $display(\"hello\");\n"
-       "  zzaa <= b;\n"
-       "  zzc  <= 1'b0;\n"  // only one space to align
-       "endtask\n"},
-      {"task  ta ; \n"
-       "$display (\"hello\" );\n"
-       "aaaaa <=  b;\n"
-       "c <= 1'b0;\n"  // need too many spaces to align
-       "endtask\n",
-       "task ta;\n"
-       "  $display(\"hello\");\n"
-       "  aaaaa <= b;\n"
-       "  c <= 1'b0;\n"  // so keep flush-left
-       "endtask\n"},
-      {"function void  fa ; \n"
-       "$display (\"hello\" );\n"
-       "aaaaa =  b;\n"
-       "c = 1'b0;\n"  // need too many spaces to align
-       "endfunction\n",
-       "function void fa;\n"
-       "  $display(\"hello\");\n"
-       "  aaaaa = b;\n"
-       "  c = 1'b0;\n"  // so keep flush-left
-       "endfunction\n"},
-      {"module  ma ;\n"
-       "always@( posedge clk) begin\n"
-       "aaaxx <= b;\n"
-       "c <= 1'b0;\n"  // need too many spaces to align
-       "end\n"
-       "endmodule\n",
-       "module ma;\n"
-       "  always @(posedge clk) begin\n"
-       "    aaaxx <= b;\n"
-       "    c <= 1'b0;\n"  // so keep flush-left
-       "  end\n"
-       "endmodule\n"},
-      {"module  ma ;\n"
-       "always@( posedge clk) begin\n"
-       "aaaxx <= b    ;\n"  // inject 4 spaces to induce alignment
-       "c <= 1'b0;\n"
-       "end\n"
-       "endmodule\n",
-       "module ma;\n"
-       "  always @(posedge clk) begin\n"
-       "    aaaxx <= b;\n"
-       "    c     <= 1'b0;\n"  // induced alignment
-       "  end\n"
-       "endmodule\n"},
-      {"module  ma ;\n"
-       "always@( posedge clk) begin\n"
-       "aaaxx <= b    ;\n"  // inject 4 spaces to induce alignment
-       "//comment\n"
-       "c <= 1'b0;\n"
-       "end\n"
-       "endmodule\n",
-       "module ma;\n"
-       "  always @(posedge clk) begin\n"
-       "    aaaxx <= b;\n"
-       "    //comment\n"       // ignored within alignment group
-       "    c     <= 1'b0;\n"  // induced alignment
-       "  end\n"
-       "endmodule\n"},
-
-      // local variable declarations as statements
-      {"task tt ;\n"
-       "int foo;\n"  // only 2 spaces needed to align
-       "bar_t baz;\n"
-       "endtask\n",
-       "task tt;\n"
-       "  int   foo;\n"  // aligned
-       "  bar_t baz;\n"
-       "endtask\n"},
-      {"function ff ;\n"
-       "bar_t baz;\n"
-       "int foo;\n"  // only 2 spaces needed to align
-       "endfunction\n",
-       "function ff;\n"
-       "  bar_t baz;\n"
-       "  int   foo;\n"  // aligned
-       "endfunction\n"},
-      {"task tt ;\n"
-       "int  foo;\n"  // too many spaces needed to align
-       "baaaar_t baz;\n"
-       "endtask\n",
-       "task tt;\n"
-       "  int foo;\n"  // so flush-left
-       "  baaaar_t baz;\n"
-       "endtask\n"},
-      {"function ff ;\n"
-       "baaaar_t baz;\n"
-       "int  foo;\n"  // too many spaces needed to align
-       "endfunction\n",
-       "function ff;\n"
-       "  baaaar_t baz;\n"
-       "  int foo;\n"  // so flush-left
-       "endfunction\n"},
-      {"task tt ;\n"
-       "int        foo;\n"  // injected spaces to induce alignment
-       "baaaar_t baz;\n"
-       "endtask\n",
-       "task tt;\n"
-       "  int      foo;\n"  // aligned
-       "  baaaar_t baz;\n"
-       "endtask\n"},
-      {"function ff ;\n"
-       "baaaar_t baz    ;\n"  // injected spaces to induce alignment
-       "int  foo;\n"
-       "endfunction\n",
-       "function ff;\n"
-       "  baaaar_t baz;\n"
-       "  int      foo;\n"  // so aligned
-       "endfunction\n"},
-
-      // formal parameters
-      {"module pp #(\n"
-       "int W,\n"
-       "type T\n"
-       ") ();\n"
-       "endmodule : pp\n",
-       "module pp #(\n"
-       "    int  W,\n"  // alignment adds few spaces, so do it
-       "    type T\n"
-       ") ();\n"
-       "endmodule : pp\n"},
-      {"module pp #(\n"
-       "int W,\n"
-       "int[xx:yy] T\n"
-       ") ();\n"
-       "endmodule : pp\n",
-       "module pp #(\n"
-       "    int W,\n"  // alignment adds many spaces, so flush-left
-       "    int [xx:yy] T\n"
-       ") ();\n"
-       "endmodule : pp\n"},
-      {"module pp #(\n"
-       "int W,\n"
-       "int[xx:yy]     T\n"  // user injected spaces intentionally
-       ") ();\n"
-       "endmodule : pp\n",
-       "module pp #(\n"
-       "    int         W,\n"  // ... trigger alignment
-       "    int [xx:yy] T\n"
-       ") ();\n"
-       "endmodule : pp\n"},
-
-      // class member variables
-      {"class  cc ;\n"
-       "int my_int;\n"
-       "bar_t my_bar;\n"
-       "endclass:cc\n",
-       "class cc;\n"
-       "  int   my_int;\n"  // align doesn't add too many spaces, so align
-       "  bar_t my_bar;\n"
-       "endclass : cc\n"},
-      {"class  cc ;\n"
-       "int   my_int;\n"
-       "foo_pkg::bar_t my_bar;\n"
-       "endclass:cc\n",
-       "class cc;\n"
-       "  int my_int;\n"  // align would add too many spaces, so flush-left
-       "  foo_pkg::bar_t my_bar;\n"
-       "endclass : cc\n"},
-      {"class  cc ;\n"
-       "int     my_int;\n"  // intentional excessive spaces, trigger alignment
-       "foo_pkg::bar_t my_bar;\n"
-       "endclass:cc\n",
-       "class cc;\n"
-       "  int            my_int;\n"
-       "  foo_pkg::bar_t my_bar;\n"
-       "endclass : cc\n"},
-      {"class  cc ;\n"
-       "int    my_int;\n"  // unable to infer user's intent, so preserve
-       "foo_pkg::bar_t  my_bar;\n"
-       "endclass:cc\n",
-       "class cc;\n"
-       "  int    my_int;\n"  // ... but still indent
-       "  foo_pkg::bar_t  my_bar;\n"
-       "endclass : cc\n"},
-
-      // case item test cases
-      {// small difference between flush-left and align, so align
-       "function f; case (x)kZZZZ  :if( b )break; default :return 2;"
-       "endcase endfunction\n",
-       "function f;\n"
-       "  case (x)\n"
-       "    kZZZZ:   if (b) break;\n"  // aligned, only adds 2 spaces
-       "    default: return 2;\n"
-       "  endcase\n"
-       "endfunction\n"},
-      {// small error relative to flush-left, so flush-left
-       "function f; case (x)kZ  :if( b )break; default :return 2;"
-       "endcase endfunction\n",
-       "function f;\n"
-       "  case (x)\n"
-       "    kZ: if (b) break;\n"  // flush-left
-       "    default: return 2;\n"
-       "  endcase\n"
-       "endfunction\n"},
-      {// intentional spacing error (delta=4) induces alignment
-       "function f; case (x)kZ  :if( b )break; default    :return 2;"
-       "endcase endfunction\n",
-       "function f;\n"
-       "  case (x)\n"
-       "    kZ:      if (b) break;\n"
-       "    default: return 2;\n"
-       "  endcase\n"
-       "endfunction\n"},
-      {// induced alignment, with ignored comments
-       "function f; case (x)kZ  :if( b )break; \n//c1\n kXX: g = f; "
-       "\n//c2\ndefault    :return 2;"
-       "endcase endfunction\n",
-       "function f;\n"
-       "  case (x)\n"
-       "    kZ:      if (b) break;\n"
-       "    //c1\n"
-       "    kXX:     g = f;\n"
-       "    //c2\n"
-       "    default: return 2;\n"
-       "  endcase\n"
-       "endfunction\n"},
-      {// induced alignment, ignore multiline case item in the middle
-       "function f; case (x)"
-       "kZ  :if( b )break; "
-       "kYY    :return 2;"          // excess spaces induce alignment
-       "    kXXXXXXXXX: begin end"  // multi-line, ignored
-       "    kWWWWW: cc = 23;\n"
-       "    kVVV: cd = 24;\n"
-       "endcase endfunction\n",
-       "function f;\n"
-       "  case (x)\n"
-       "    kZ:     if (b) break;\n"
-       "    kYY:    return 2;\n"
-       "    kXXXXXXXXX: begin\n"  // separates above/below groups
-       "    end\n"
-       "    kWWWWW: cc = 23;\n"
-       "    kVVV:   cd = 24;\n"  // aligned
-       "  endcase\n"
-       "endfunction\n"},
-      {// induced alignment, ignore multiline case item in the middle
-       "function f; case (x)"
-       "kZ  :if( b )break; "
-       "kYY    :return 2;"               // excess spaces induce alignment
-       "    kXXXXXXXXX: if(w)begin end"  // multi-line, ignored
-       "    kWWWWW: cc = 23;\n"
-       "    kVVV: cd = 24;\n"
-       "endcase endfunction\n",
-       "function f;\n"
-       "  case (x)\n"
-       "    kZ:     if (b) break;\n"
-       "    kYY:    return 2;\n"
-       "    kXXXXXXXXX:\n"   // TODO(fangism): allow this to merge with if()
-                             // else indent the following two lines
-       "    if (w) begin\n"  // separates above/below groups
-       "    end\n"
-       "    kWWWWW: cc = 23;\n"
-       "    kVVV:   cd = 24;\n"  // aligned
-       "  endcase\n"
-       "endfunction\n"},
-      {// induced alignment, ignore multiline case item in the middle
-       "task t; case (x)"
-       "kZ  :if( b )break; "
-       "kYY    :return 2;"           // excess spaces induce alignment
-       "    kXXXXXXXXX: fork  join"  // multi-line, ignored
-       "    kWWWWW: cc = 23;\n"
-       "    kVVV: cd = 24;\n"
-       "endcase endtask\n",
-       "task t;\n"
-       "  case (x)\n"
-       "    kZ:     if (b) break;\n"
-       "    kYY:    return 2;\n"
-       "    kXXXXXXXXX:\n"  // TODO(fangism): allow this to merge with fork
-                            // else indent the following two lines
-       "    fork\n"         // separates above/below groups
-       "    join\n"
-       "    kWWWWW: cc = 23;\n"
-       "    kVVV:   cd = 24;\n"  // aligned
-       "  endcase\n"
-       "endtask\n"},
-      {// case-inside: small difference between flush-left and align, so align
-       "function f; case (x)inside [0:3]  :yy=zzz; [4:11] :yy=zz;"
-       "endcase endfunction\n",
-       "function f;\n"
-       "  case (x) inside\n"
-       "    [0 : 3]:  yy = zzz;\n"  // aligned, only adds 1 spaces
-       "    [4 : 11]: yy = zz;\n"
-       "  endcase\n"
-       "endfunction\n"},
-      {// case-inside: align with comments
-       "function f; case (x)inside \n//c1\n[0:3]  :yy=zzz;\n//c2\n"
-       " [4:11] :yy=zz;\n//c3\n"
-       "endcase endfunction\n",
-       "function f;\n"
-       "  case (x) inside\n"
-       "    //c1\n"
-       "    [0 : 3]:  yy = zzz;\n"  // aligned, only adds 1 spaces
-       "    //c2\n"
-       "    [4 : 11]: yy = zz;\n"
-       "    //c3\n"
-       "  endcase\n"
-       "endfunction\n"},
-      {// case-inside: flush left
-       "function f; case (x)inside [0:3]  :yy=zzz; [4:999999] :yy=zz;"
-       "endcase endfunction\n",
-       "function f;\n"
-       "  case (x) inside\n"
-       "    [0 : 3]: yy = zzz;\n"  // flush-left
-       "    [4 : 999999]: yy = zz;\n"
-       "  endcase\n"
-       "endfunction\n"},
-      {// case-inside: induce alignment
-       "function f; case (x)inside [0:3    ]  :yy=zzz; [4:999999] :yy=zz;"
-       "endcase endfunction\n",
-       "function f;\n"
-       "  case (x) inside\n"
-       "    [0 : 3]:      yy = zzz;\n"  // aligned
-       "    [4 : 999999]: yy = zz;\n"
-       "  endcase\n"
-       "endfunction\n"},
-      {// case-generate: align would add few spaces, so align
-       "module mc ; case (x)kZ  : gg h(); kXYY :j kk();"
-       "endcase endmodule\n",
-       "module mc;\n"
-       "  case (x)\n"
-       "    kZ:   gg h ();\n"  // align
-       "    kXYY: j kk ();\n"
-       "  endcase\n"
-       "endmodule\n"},
-      {// case-generate + comment: align would add few spaces, so align
-       "module mc ; case (x)kZ  : gg h(); \n//c1\n kXYY :j kk();"
-       "endcase endmodule\n",
-       "module mc;\n"
-       "  case (x)\n"
-       "    kZ:   gg h ();\n"  // align
-       "    //c1\n"
-       "    kXYY: j kk ();\n"
-       "  endcase\n"
-       "endmodule\n"},
-      {// case-generate: align would add too many space, so flush-left
-       "module mc ; case (x)kZ  : gg h(); kXYYYY :j kk();"
-       "endcase endmodule\n",
-       "module mc;\n"
-       "  case (x)\n"
-       "    kZ: gg h ();\n"  // flush-left
-       "    kXYYYY: j kk ();\n"
-       "  endcase\n"
-       "endmodule\n"},
-      {// case-generate: inject spaces to induce alignment
-       "module mc ; case (x)kZ  : gg h(); kXYYYY :     j kk();"
-       "endcase endmodule\n",
-       "module mc;\n"
-       "  case (x)\n"
-       "    kZ:     gg h ();\n"  // align
-       "    kXYYYY: j kk ();\n"
-       "  endcase\n"
-       "endmodule\n"},
-      {// randcase: align (small difference from flush-left)
-       "task trc  ;randcase 10: x = 1; 1: x = 3; endcase endtask",
-       "task trc;\n"
-       "  randcase\n"
-       "    10: x = 1;\n"
-       "    1:  x = 3;\n"  // aligned
-       "  endcase\n"
-       "endtask\n"},
-      {// randcase: inferred flush-left
-       "task trc  ;randcase 10000: x = 1; 1: x = 3; endcase endtask",
-       "task trc;\n"
-       "  randcase\n"
-       "    10000: x = 1;\n"
-       "    1: x = 3;\n"
-       "  endcase\n"
-       "endtask\n"},
-      {// randcase: induce alignment
-       "task trc  ;randcase 10000: x = 1    ; 1: x = 3; endcase endtask",
-       "task trc;\n"
-       "  randcase\n"
-       "    10000: x = 1;\n"
-       "    1:     x = 3;\n"  // aligned
-       "  endcase\n"
-       "endtask\n"},
-
-      // distributions
-      {"class foo;\n"
-       "constraint c { "
-       "timer_enable dist {\n"
-       "8'hfe :=  9 , \n"
-       "12'hfff  := 1 }; "
-       "} endclass\n",
-       "class foo;\n"
-       "  constraint c {\n"
-       "    timer_enable dist {\n"
-       "      8'hfe   := 9,\n"  // only two spaces needed to align
-       "      12'hfff := 1\n"   // so align
-       "    };\n"
-       "  }\n"
-       "endclass\n"},
-      {"class foo;\n"
-       "constraint c { "
-       "timer_enable dist {\n"
-       "[ 8'h0 : 8'hfe ] :/  9 , \n"
-       "8'hff  :/ 1 }; "  // takes many spaces to align this, so...
-       "} endclass\n",
-       "class foo;\n"
-       "  constraint c {\n"
-       "    timer_enable dist {\n"
-       "      [8'h0 : 8'hfe] :/ 9,\n"
-       "      8'hff :/ 1\n"  // flush-left
-       "    };\n"
-       "  }\n"
-       "endclass\n"},
-      {"class foo;\n"
-       "constraint c { "
-       "timer_enable dist {\n"
-       "[ 8'h0 : 8'hfe ] :/  9 , \n"
-       "8'hff  :/     1 }; "  // inject excess spaces to trigger alignment
-       "} endclass\n",
-       "class foo;\n"
-       "  constraint c {\n"
-       "    timer_enable dist {\n"
-       "      [8'h0 : 8'hfe] :/ 9,\n"
-       "      8'hff          :/ 1\n"  // aligned
-       "    };\n"
-       "  }\n"
-       "endclass\n"},
-      {"class foo;\n"
-       "constraint c { "
-       "timer_enable dist {\n"
-       "//comment1\n"
-       "[ 8'h0 : 8'hfe ] :/  9 , \n"
-       "//comment2\n"
-       "8'hff  :/     1 \n"
-       "//comment3\n"
-       "}; "  // inject excess spaces to trigger alignment
-       "} endclass\n",
-       "class foo;\n"
-       "  constraint c {\n"
-       "    timer_enable dist {\n"
-       "      //comment1\n"
-       "      [8'h0 : 8'hfe] :/ 9,\n"
-       "      //comment2\n"           // align across comment
-       "      8'hff          :/ 1\n"  // aligned
-       "      //comment3\n"
-       "    };\n"
-       "  }\n"
-       "endclass\n"},
-      {"module foo ();\n"
-       "  always @(posedge bar) begin\n"
-       "    if (1==1) begin\n"
-       "      ham();\n"
-       "    end else if (2==2) begin\n"
-       "      jam();\n"
-       "    end else begin\n"
-       "      spam();\n"
-       "    end\n"
-       "  end\n"
-       "endmodule\n",
-       "module foo ();\n"
-       "  always @(posedge bar) begin\n"
-       "    if (1 == 1) begin\n"
-       "      ham();\n"
-       "    end else if (2 == 2) begin\n"
-       "      jam();\n"
-       "    end else begin\n"
-       "      spam();\n"
-       "    end\n"
-       "  end\n"
-       "endmodule\n"},
-  };
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  // Override some settings to test auto-inferred alignment.
-  style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kInferUserIntent);
-
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}  // NOLINT(readability/fn_size)
-
-static constexpr FormatterTestCase kFormatterWideTestCases[] = {
-    // specify blocks
-    {"module  specify_tests ;\n"
-     "specify\n"  // empty list
-     "endspecify\n"
-     "endmodule",
-     "module specify_tests;\n"
-     "  specify\n"
-     "  endspecify\n"
-     "endmodule\n"},
-    {"module  specify_tests ;\n"
-     "specify\n"
-     "$recrem (posedge R, posedge C,\n"
-     "t1, t2);\n"
-     "endspecify\n"
-     "endmodule",
-     "module specify_tests;\n"
-     "  specify\n"
-     "    $recrem(posedge R, posedge C, t1, t2);\n"
-     "  endspecify\n"
-     "endmodule\n"},
-    {"module  specify_tests ;\n"
-     "specify\n"
-     "// TODO: add this\n"
-     "endspecify \n"
-     "endmodule",
-     "module specify_tests;\n"
-     "  specify\n"
-     "    // TODO: add this\n"
-     "  endspecify\n"
-     "endmodule\n"},
-    {"module  specify_tests ;\n"
-     "specify  \n"
-     "  //c1\n"
-     "$setup (  posedge A, posedge B,\n"
-     "t1);//c2\n"
-     " //c3\n"
-     "$hold (  posedge B , posedge A,t2);    //c4\n"
-     "\t//c5\n"
-     "endspecify\n"
-     "endmodule",
-     "module specify_tests;\n"
-     "  specify\n"
-     "    //c1\n"
-     "    $setup(posedge A, posedge B, t1);  //c2\n"
-     "    //c3\n"
-     "    $hold(posedge B, posedge A, t2);  //c4\n"
-     "    //c5\n"
-     "  endspecify\n"
-     "endmodule\n"},
-    {"module  specify_tests ;\n"
-     "specify  \n"
-     "$setup (  posedge A, posedge B,\n"
-     "t1);\n"
-     "$hold (  posedge B , posedge A,t2);\n"
-     "endspecify\n"
-     "endmodule",
-     "module specify_tests;\n"
-     "  specify\n"
-     "    $setup(posedge A, posedge B, t1);\n"
-     "    $hold(posedge B, posedge A, t2);\n"
-     "  endspecify\n"
-     "endmodule\n"},
-    {"module  specify_tests ;\n"
-     "specify  \n"
-     "  `ifdef CCC\n"
-     "$setup (  posedge A, posedge B,\n"
-     "t1);\n"
-     " `else\n"
-     "$hold (  posedge B , posedge A,t2);   \n"
-     "\t`endif\n"
-     "endspecify\n"
-     "endmodule",
-     "module specify_tests;\n"
-     "  specify\n"
-     "`ifdef CCC\n"
-     "    $setup(posedge A, posedge B, t1);\n"
-     "`else\n"
-     "    $hold(posedge B, posedge A, t2);\n"
-     "`endif\n"
-     "  endspecify\n"
-     "endmodule\n"},
-};
-
-// These tests just need a larger column limit to fit on one line.
-TEST(FormatterEndToEndTest, VerilogFormatWideTest) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 60;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  for (const auto &test_case : kFormatterWideTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, DisableModulePortDeclarations) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {"", ""},
-      {"\n", "\n"},
-      {"\n\n", "\n\n"},
-      {"module  m  ;\t\n"
-       "  endmodule\n",
-       "module m;\n"
-       "endmodule\n"},
-      {"module  m(   ) ;\n"
-       "  endmodule\n",
-       "module m ();\n"  // empty ports formatted compactly
-       "endmodule\n"},
-      {// for a single port, the alignment handler doesn't even consider it a
-       // group so it falls back to standard flush-left behavior.
-       "module  m   ( input     clk  )\t;\n"
-       "  endmodule\n",
-       "module m (\n"
-       "    input clk\n"
-       ");\n"
-       "endmodule\n"},
-      {// example with two ports
-       "module  m   (\n"
-       "input  clk,\n"
-       "output bar\n"
-       ")\t;\n"
-       "  endmodule\n",
-       "module m (\n"
-       "    input  clk,\n"  // indented, but internal pre-existing spacing
-                            // preserved
-       "    output bar\n"
-       ");\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.port_declarations_alignment = verible::AlignmentPolicy::kPreserve;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, DisableModuleInstantiations) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {"", ""},
-      {"\n", "\n"},
-      {"\n\n", "\n\n"},
-      {"module  m  ;\t\n"
-       "  endmodule\n",
-       "module m;\n"
-       "endmodule\n"},
-      {"module  m  ;\t\n"
-       "foo bar();"
-       "  endmodule\n",
-       "module m;\n"
-       "  foo bar ();\n"  // indentation still takes effect
-       "endmodule\n"},
-      {"module  m  ;\t\n"
-       "logic   xyz;"
-       "wire\tabc;"
-       "  endmodule\n",
-       "module m;\n"
-       "  logic xyz;\n"  // indentation still takes effect
-       "  wire  abc;\n"  // aligned too
-       "endmodule\n"},
-      {"  function f  ;\t\n"
-       " endfunction\n",
-       "function f;\n"
-       "endfunction\n"},
-      {"  function f  ;\t"
-       "foo  bar,baz; "
-       " endfunction\n",
-       "function f;\n"
-       "  foo bar, baz;\n"
-       "endfunction\n"},
-      {"  task  t  ;\t"
-       "foo  bar,baz; "
-       " endtask\n",
-       "task t;\n"
-       "  foo bar, baz;\n"
-       "endtask\n"},
-      {"module  m  ;\t\n"
-       "foo  bar(   .baz(baz)   );"
-       "  endmodule\n",
-       "module m;\n"
-       "  foo bar (.baz(baz));\n"  // indentation still takes effect
-       "endmodule\n"},
-      {"module  m  ;\t\n"
-       "foo  bar(\n"
-       "        .baz  (baz  ),\n"  // example of user-manual alignment
-       "        .blaaa(blaaa)\n"
-       ");"
-       "  endmodule\n",
-       "module m;\n"
-       "  foo bar (\n"           // indentation still takes effect
-       "      .baz  (baz  ),\n"  // named port connections preserved
-       "      .blaaa(blaaa)\n"   // named port connections preserved
-       "  );\n"                  // this indentation is fixed
-       "endmodule\n"},
-      {"module  m  ;\t\n"
-       "foo  #(   .baz(baz)   ) bar();"  // named parameters
-       "  endmodule\n",
-       "module m;\n"
-       "  foo #(.baz(baz)) bar ();\n"  // indentation still takes effect
-       "endmodule\n"},
-      {"module  m  ;\t\n"
-       "foo  #(\n"
-       "        .baz  (baz  ),\n"  // example of user-manual alignment
-       "        .blaaa(blaaa)\n"
-       ")  bar( );"
-       "  endmodule\n",
-       "module m;\n"
-       "  foo #(\n"              // indentation still takes effect
-       "      .baz  (baz  ),\n"  // named parameter arguments preserved
-       "      .blaaa(blaaa)\n"   // named parameter arguments preserved
-       "  ) bar ();\n"           // this indentation is fixed
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  // Testing preservation of spaces
-  style.named_parameter_alignment = AlignmentPolicy::kPreserve;
-  style.named_port_alignment = AlignmentPolicy::kPreserve;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, DisableTryWrapLongLines) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {"", ""},
-      {"\n", "\n"},
-      {"\n\n", "\n\n"},
-      {"module  m  ;\t\n"
-       "  endmodule\n",
-       "module m;\n"
-       "endmodule\n"},
-      {"module  m(   ) ;\n"
-       "  endmodule\n",
-       "module m ();\n"
-       "endmodule\n"},
-      {"module  m(   ) ;\n"
-       "initial assign a = b;\n"
-       "  endmodule\n",
-       "module m ();\n"
-       "  initial assign a = b;\n"
-       "endmodule\n"},
-      {"module  m(   ) ;\n"
-       "initial assign a = {never +gonna +give +you +up,\n"
-       "never + gonna +Let +you +down};\n"
-       "  endmodule\n",
-       "module m ();\n"
-       "  initial\n"
-       "    assign a = {\n"
-       "      never + gonna + give + you + up,\n"
-       "      never + gonna + Let + you + down\n"
-       "    };\n"
-       "endmodule\n"},
-      {"module  m(   ) ;\n"
-       "initial assign a = {never +gonna +give +you +up+\n"  // over 40 columns,
-                                                             // give up
-       "never + gonna +Let +you +down};\n"
-       "  endmodule\n",
-       "module m ();\n"
-       "  initial\n"
-       "    assign a = {\n"
-       "      never +gonna +give +you +up+\n"  // indented properly, but
-       "never + gonna +Let +you +down\n"       // preserved original
-       "    };\n"
-       "endmodule\n"},
-      {// The if-header is a single leaf partition, and does not fit,
-       // so its original spacing should be preserved.
-       // We deliberately insert weird spacing to show that it is preserved.
-       "function f;\n"
-       "if ((xxx.aaaa >= bbbbbbbbbbbbbbb) &&\n"
-       "      ((ccc.ddd  +  eee.ffffff * g) <=\n"
-       "       (hhhhhhhhhhhhhhh+iiiiiiiiiiiiiiiiiiii))) begin\n"
-       "end\n"
-       "endfunction\n",
-       "function f;\n"
-       "  if ((xxx.aaaa >= bbbbbbbbbbbbbbb) &&\n"  // indentation fixed
-       "      ((ccc.ddd  +  eee.ffffff * g) <=\n"
-       "       (hhhhhhhhhhhhhhh+iiiiiiiiiiiiiiiiiiii))) begin\n"
-       "  end\n"  // indentation fixed
-       "endfunction\n"},
-
-      // Make sure indentation still works with wrapping disabled,
-      // and leaf partitions fit on one line.
-      {"function void f();\n"
-       "for (int i = N; i > 0; i--) begin\n"
-       "end\n"
-       "endfunction\n",
-       "function void f();\n"
-       "  for (int i = N; i > 0; i--) begin\n"
-       "  end\n"
-       "endfunction\n"},
-      {"function void f();"
-       "if(i > 0 ) begin end "
-       "endfunction",
-       "function void f();\n"
-       "  if (i > 0) begin\n"
-       "  end\n"
-       "endfunction\n"},
-      {"function void f();"  // newlines absent from input
-       "for (int i=N; i>0; i--) begin end "
-       "endfunction",
-       "function void f();\n"
-       "  for (int i = N; i > 0; i--) begin\n"  // spacing corrected
-       "  end\n"
-       "endfunction\n"},
-      {"module m( );\n"
-       "  always_ff  @  (  posedge  (  clk  )  ) begin\n"
-       "out  <=  rst_clk  ?  0 : in  ;\n"
-       "end\n"
-       "endmodule : simple\n",
-       "module m ();\n"
-       "  always_ff @(posedge (clk)) begin\n"
-       "    out <= rst_clk ? 0 : in;\n"
-       "  end\n"
-       "endmodule : simple\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.try_wrap_long_lines = false;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, ModulePortDeclarationsIndentNotWrap) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {"", ""},
-      {"\n", "\n"},
-      {"\n\n", "\n\n"},
-      {"module  m  ;\t\n"
-       "  endmodule\n",
-       "module m;\n"
-       "endmodule\n"},
-      {"module  m(   ) ;\n"
-       "  endmodule\n",
-       "module m ();\n"  // empty ports formatted compactly
-       "endmodule\n"},
-      {// single port example
-       "module  m   ( input     clk  )\t;\n"
-       "  endmodule\n",
-       "module m (\n"
-       "  input clk\n"  // 2 spaces
-       ");\n"
-       "endmodule\n"},
-      {// example with two ports
-       "module  m   (\n"
-       "input  clk,\n"
-       "output bar\n"
-       ")\t;\n"
-       "  endmodule\n",
-       "module m (\n"
-       "  input  clk,\n"  // indented 2 spaces, and aligned
-       "  output bar\n"
-       ");\n"
-       "endmodule\n"},
-      {// interface example
-       "interface  handshake   (\n"
-       "wire req,\n"
-       "wire ack\n"
-       ")\t;\n"
-       "  endinterface\n",
-       "interface handshake (\n"
-       "  wire req,\n"  // indented 2 spaces
-       "  wire ack\n"
-       ");\n"
-       "endinterface\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  // Indent 2 spaces instead of wrapping 4 spaces.
-  style.port_declarations_indentation = IndentationStyle::kIndent;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, NamedPortConnectionsIndentNotWrap) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {"", ""},
-      {"\n", "\n"},
-      {"\n\n", "\n\n"},
-      {"module  m  ;\t\n"
-       "  endmodule\n",
-       "module m;\n"
-       "endmodule\n"},
-      {"module  m(   ) ;\n"
-       "  endmodule\n",
-       "module m ();\n"  // empty ports formatted compactly
-       "endmodule\n"},
-      {// single port example
-       "module  m ;\n"
-       "foo bar( .clk( clk ) )\t;\n"
-       "  endmodule\n",
-       "module m;\n"
-       "  foo bar (.clk(clk));\n"
-       "endmodule\n"},
-      {// two port example
-       "module  m ;\n"
-       "foo bar( .clk2( clk ),.data (data) )\t;\n"
-       "  endmodule\n",
-       "module m;\n"
-       "  foo bar (\n"
-       "    .clk2(clk),\n"  // indent only +2 spaces
-       "    .data(data)\n"
-       "  );\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  // Indent 2 spaces instead of wrapping 4 spaces.
-  style.named_port_indentation = IndentationStyle::kIndent;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, WrapEndElseStatements) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {"module foo ();\n"
-       "  always @(posedge bar) begin\n"
-       "    if (1==1) begin\n"
-       "      ham();\n"
-       "    end else if (2==2) begin\n"
-       "      jam();\n"
-       "    end else begin\n"
-       "      spam();\n"
-       "    end\n"
-       "  end\n"
-       "endmodule\n",
-       "module foo ();\n"
-       "  always @(posedge bar) begin\n"
-       "    if (1 == 1) begin\n"
-       "      ham();\n"
-       "    end\n"
-       "    else if (2 == 2) begin\n"
-       "      jam();\n"
-       "    end\n"
-       "    else begin\n"
-       "      spam();\n"
-       "    end\n"
-       "  end\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.wrap_end_else_clauses = true;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, FormalParametersIndentNotWrap) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {"", ""},
-      {"\n", "\n"},
-      {"\n\n", "\n\n"},
-      {"module  m  ;\t\n"
-       "  endmodule\n",
-       "module m;\n"
-       "endmodule\n"},
-      {"module  m #(   ) ;\n"  // empty parameters
-       "  endmodule\n",
-       "module m #();\n"
-       "endmodule\n"},
-      {// single parameter example
-       "module  m   #( int W = 2)\t;\n"
-       "  endmodule\n",
-       "module m #(\n"
-       "  int W = 2\n"  // indented 2 spaces
-       ");\n"
-       "endmodule\n"},
-      {// module with two parameters
-       "module  m   #(\n"
-       "int W = 2,\n"
-       "int L = 4\n"
-       ")\t;\n"
-       "  endmodule\n",
-       "module m #(\n"
-       "  int W = 2,\n"  // indented 2 spaces
-       "  int L = 4\n"
-       ");\n"
-       "endmodule\n"},
-      {// interface with two parameters
-       "interface  m   #(\n"
-       "int W = 2,\n"
-       "int L = 4\n"
-       ")\t;\n"
-       "  endinterface\n",
-       "interface m #(\n"
-       "  int W = 2,\n"  // indented 2 spaces
-       "  int L = 4\n"
-       ");\n"
-       "endinterface\n"},
-      {// class with two parameters
-       "class  c   #(\n"
-       "int W = 2,\n"
-       "int L = 4\n"
-       ")\t;\n"
-       "  endclass\n",
-       "class c #(\n"
-       "  int W = 2,\n"  // indented 2 spaces
-       "  int L = 4\n"
-       ");\n"
-       "endclass\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  // Indent 2 spaces instead of wrapping 4 spaces.
-  style.formal_parameters_indentation = IndentationStyle::kIndent;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, NamedParametersIndentNotWrap) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {"", ""},
-      {"\n", "\n"},
-      {"\n\n", "\n\n"},
-      {"module  m  ;\t\n"
-       "  endmodule\n",
-       "module m;\n"
-       "endmodule\n"},
-      {"module  m #(   ) ;\n"  // empty parameters
-       "  endmodule\n",
-       "module m #();\n"
-       "endmodule\n"},
-      {"module  m  ;\t\n"
-       " foo #()bar();\n"
-       "  endmodule\n",
-       "module m;\n"
-       "  foo #() bar ();\n"
-       "endmodule\n"},
-      {// one named parameter
-       "module  m ;\n"
-       "foo #(.W(1)) bar();\n"
-       "  endmodule\n",
-       "module m;\n"
-       "  foo #(.W(1)) bar ();\n"
-       "endmodule\n"},
-      {// two named parameters
-       "module  m ;\n"
-       "foo #(.W(1), .L(2)) bar();\n"
-       "  endmodule\n",
-       "module m;\n"
-       "  foo #(\n"
-       "    .W(1),\n"  // indent +2 spaces only
-       "    .L(2)\n"
-       "  ) bar ();\n"
-       "endmodule\n"},
-      {// class data member with two parameters
-       "class  c  ;\n"
-       " foo_pkg::bar_t#(\n"
-       ".W(2),.L(4)"
-       ") baz;\n"
-       "  endclass\n",
-       "class c;\n"
-       "  foo_pkg::bar_t #(\n"
-       "    .W(2),\n"  // indent +2 spaces only
-       "    .L(4)\n"
-       "  ) baz;\n"
-       "endclass\n"},
-      {// typedef with two parameters
-       "typedef \n"
-       " foo_pkg::bar_t  #("
-       ".W(2),.L(4)"
-       ") baz;\n",
-       "typedef foo_pkg::bar_t#(\n"
-       "  .W(2),\n"  // indent +2 spaces only
-       "  .L(4)\n"
-       ") baz;\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  // Indent 2 spaces instead of wrapping 4 spaces.
-  style.named_parameter_indentation = IndentationStyle::kIndent;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-struct SelectLinesTestCase {
-  std::string_view input;
-  LineNumberSet lines;  // explicit set of lines to enable formatting
-  std::string_view expected;
-};
-
-// Tests that formatter honors selected line numbers.
-TEST(FormatterEndToEndTest, SelectLines) {
-  const SelectLinesTestCase kTestCases[] = {
-      {"", {}, ""},
-      {"", {{1, 2}}, ""},
-      {// expect all three lines for format
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n",
-       {},
-       "parameter int foo_line1 = 0;\n"
-       "parameter int foo_line2 = 0;\n"
-       "parameter int foo_line3 = 0;\n"},
-      {// expect only one line to format
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n",
-       {{1, 2}},
-       "parameter int foo_line1 = 0;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n"},
-      {// expect only one line to format
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n",
-       {{2, 3}},
-       "  parameter    int foo_line1 =     0 ;\n"
-       "parameter int foo_line2 = 0;\n"
-       "  parameter    int foo_line3 =     0 ;\n"},
-      {// expect only one line to format
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n",
-       {{3, 4}},
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "parameter int foo_line3 = 0;\n"},
-      {// expect to format two lines
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n",
-       {{1, 3}},
-       "parameter int foo_line1 = 0;\n"
-       "parameter int foo_line2 = 0;\n"
-       "  parameter    int foo_line3 =     0 ;\n"},
-      {// expect to format two lines
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n",
-       {{2, 4}},
-       "  parameter    int foo_line1 =     0 ;\n"
-       "parameter int foo_line2 = 0;\n"
-       "parameter int foo_line3 = 0;\n"},
-      {// expect to format two lines
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n",
-       {{1, 2}, {3, 4}},
-       "parameter int foo_line1 = 0;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "parameter int foo_line3 = 0;\n"},
-      {// expect to format all lines
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n",
-       {{1, 4}},
-       "parameter int foo_line1 = 0;\n"
-       "parameter int foo_line2 = 0;\n"
-       "parameter int foo_line3 = 0;\n"},
-      {// expect to format no lines (line numbers out of bounds)
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n",
-       {{4, 6}},
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n"},
-      {// expect to format all lines
-       "// verilog_format: on\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n"
-       "  parameter    int foo_line4 =     0 ;\n",
-       {},
-       "// verilog_format: on\n"
-       "parameter int foo_line2 = 0;\n"
-       "parameter int foo_line3 = 0;\n"
-       "parameter int foo_line4 = 0;\n"},
-      {// expect to format no lines
-       "// verilog_format: off\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n"
-       "  parameter    int foo_line4 =     0 ;\n",
-       {},
-       "// verilog_format: off\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n"
-       "  parameter    int foo_line4 =     0 ;\n"},
-      {// expect to format some lines
-       "// verilog_format: on\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n"
-       "  parameter    int foo_line4 =     0 ;\n",
-       {{3, 5}},
-       "// verilog_format: on\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "parameter int foo_line3 = 0;\n"  // disable lines 3,4
-       "parameter int foo_line4 = 0;\n"},
-      {// enable all lines, but respect format-off
-       "  parameter    int foo_line1 =     0 ;\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "// verilog_format: off\n"
-       "  parameter    int foo_line4 =     0 ;\n",
-       {{1, 5}},
-       "parameter int foo_line1 = 0;\n"
-       "parameter int foo_line2 = 0;\n"
-       "// verilog_format: off\n"
-       "  parameter    int foo_line4 =     0 ;\n"},
-      {// enable all lines, but respect format-off
-       "  parameter    int foo_line1 =     0 ;\n"
-       "// verilog_format: off\n"
-       "  parameter    int foo_line3 =     0 ;\n"
-       "// verilog_format: on\n"
-       "  parameter    int foo_line5 =     0 ;\n",
-       {{1, 6}},
-       "parameter int foo_line1 = 0;\n"
-       "// verilog_format: off\n"
-       "  parameter    int foo_line3 =     0 ;\n"
-       "// verilog_format: on\n"
-       "parameter int foo_line5 = 0;\n"},
-      {// enable all lines, but respect format-off
-       "// verilog_format: off\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n"
-       "// verilog_format: on\n"
-       "  parameter    int foo_line5 =     0 ;\n",
-       {{1, 6}},
-       "// verilog_format: off\n"
-       "  parameter    int foo_line2 =     0 ;\n"
-       "  parameter    int foo_line3 =     0 ;\n"
-       "// verilog_format: on\n"
-       "parameter int foo_line5 = 0;\n"},
-      {"module m;\n"
-       "  if (foo) begin:l1\n"
-       "    if (foo) begin:l2\n"
-       "      always_comb\n"  // normally this line and next would fit together
-       "        d<=#1ps   x_lat\t;\n"  // only format this line, 5
-       "    end : l2\n"
-       "  end : l1\n"
-       "endmodule\n",
-       {{5, 6}},
-       "module m;\n"
-       "  if (foo) begin:l1\n"
-       "    if (foo) begin:l2\n"
-       "      always_comb\n"  // incremental mode prevents joining next line
-       "        d <= #1ps x_lat;\n"  // only this line changed
-       "    end : l2\n"
-       "  end : l1\n"
-       "endmodule\n"},
-
-      // Next three test cases: one whole-file, two incremental
-      {"module m(\n"
-       "  input wire f,\n"
-       "  input  foo::bar  ggg\n"
-       ");\n"
-       "endmodule:m\n",
-       {},  // format all lines
-       "module m (\n"
-       "    input wire     f,\n"
-       "    input foo::bar ggg\n"
-       ");\n"
-       "endmodule : m\n"},
-      {"module m(\n"
-       "  input wire f,\n"
-       "  input  foo::bar  ggg\n"  // "new line", formatted incrementally
-       ");\n"
-       "endmodule:m\n",
-       {{3, 4}},  // format incrementally
-       "module m(\n"
-       "  input wire f,\n"
-       "    input  foo::bar  ggg\n"  // "new line" remains untouched
-       ");\n"
-       "endmodule:m\n"},
-      {"module m(\n"
-       "  input  wire   f,\n"  // "new line", formatted incrementally
-       "  input  foo::bar  ggg\n"
-       ");\n"
-       "endmodule:m\n",
-       {{2, 3}},  // format incrementally
-       "module m(\n"
-       "    input  wire   f,\n"  // "new line" indented, but other spaces kept
-       "  input  foo::bar  ggg\n"
-       ");\n"
-       "endmodule:m\n"},
-  };
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status = FormatVerilog(test_case.input, "<filename>", style,
-                                      stream, test_case.lines);
-    EXPECT_OK(status) << status.message() << '\n'
-                      << "Lines: " << test_case.lines;
-    EXPECT_EQ(stream.str(), test_case.expected)
-        << "code:\n"
-        << test_case.input << "\nlines: " << test_case.lines;
-  }
-}
-
-// These tests verify the mode where horizontal spacing is discarded while
-// vertical spacing is preserved.
-TEST(FormatterEndToEndTest, PreserveVSpacesOnly) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      // {input, expected},
-      // No tokens cases: still preserve vertical spacing, but not horizontal
-      {"", ""},
-      {"    ", ""},
-      {"\n", "\n"},
-      {"\n\n", "\n\n"},
-      {"  \n", "\n"},
-      {"\n  ", "\n"},
-      {"  \n  ", "\n"},
-      {"  \n  \t\t\n\t  ", "\n\n"},
-
-      // The remaining cases have at least one non-whitespace token.
-
-      // single comment
-      {"//\n", "//\n"},
-      {"//  \n", "//  \n"},  // trailing spaces inside comment untouched
-      {"\n//\n", "\n//\n"},
-      {"\n\n//\n", "\n\n//\n"},
-      {"\n//\n\n", "\n//\n\n"},
-      {"      //\n", "//\n"},  // spaces before comment discarded
-      {"   \n   //\n", "\n//\n"},
-      {"   \n   //\n  \n  ", "\n//\n\n"},  // trailing spaces discarded
-
-      // multi-comment
-      {"//\n//\n", "//\n//\n"},
-      {"\n//\n\n//\n\n", "\n//\n\n//\n\n"},
-      {"\n//\n\n//\n", "\n//\n\n//\n"},  // blank line between comments
-
-      // Module cases with token partition boundary (before 'endmodule').
-      {"module foo;endmodule\n", "module foo;\nendmodule\n"},
-      {"module foo;\nendmodule\n", "module foo;\nendmodule\n"},
-      {"module foo;\n\nendmodule\n", "module foo;\n\nendmodule\n"},
-      {"\nmodule foo;endmodule\n", "\nmodule foo;\nendmodule\n"},
-      {"\nmodule foo     ;    endmodule\n", "\nmodule foo;\nendmodule\n"},
-      {"\nmodule\nfoo\n;endmodule\n", "\nmodule foo;\nendmodule\n"},
-      {"\nmodule foo;endmodule\n\n\n", "\nmodule foo;\nendmodule\n\n\n"},
-      {"\n\n\nmodule foo;endmodule\n", "\n\n\nmodule foo;\nendmodule\n"},
-      {"\nmodule\nfoo\n;\n\n\nendmodule\n", "\nmodule foo;\n\n\nendmodule\n"},
-
-      // Module cases with one indented item, various original vertical spacing
-      {"module foo;wire w;endmodule\n", "module foo;\n  wire w;\nendmodule\n"},
-      {"  module   foo  ;wire    w  ;endmodule  \n  ",
-       "module foo;\n  wire w;\nendmodule\n"},
-      {"\nmodule\nfoo\n;\nwire\nw\n;endmodule\n\n",
-       "\nmodule foo;\n  wire w;\nendmodule\n\n"},
-      {"\n\nmodule\nfoo\n;\n\n\nwire\nw\n;\n\nendmodule\n\n",
-       "\n\nmodule foo;\n\n\n  wire w;\n\nendmodule\n\n"},
-
-      // The following cases show that some horizontal whitespace is discarded,
-      // while vertical spacing is preserved on partition boundaries.
-      {"     module  foo\t   \t;    endmodule   \n",
-       "module foo;\nendmodule\n"},
-      {"\t\n     module  foo\t\t;    endmodule   \n",
-       "\nmodule foo;\nendmodule\n"},
-
-      // Module with comments intermingled.
-      {
-          "//1\nmodule foo;//2\nwire w;//3\n//4\nendmodule\n",
-          "//1\nmodule foo;  //2\n  wire w;  //3\n  //4\nendmodule\n"
-          // TODO(fangism): whether or not //4 should be indented is
-          // questionable (in similar cases below too).
-      },
-      {// now with extra blank lines
-       "//1\n\nmodule foo;//2\n\nwire w;//3\n\n//4\n\nendmodule\n\n",
-       "//1\n\nmodule foo;  //2\n\n  wire w;  //3\n\n  //4\n\nendmodule\n\n"},
-
-      {
-          // module with comments-only in some empty blocks, properly indented
-          "  // humble module\n"
-          "  module foo (// non-port comment\n"
-          "// port comment 1\n"
-          "// port comment 2\n"
-          ");// header trailing comment\n"
-          "// item comment 1\n"
-          "// item comment 2\n"
-          "endmodule\n",
-          "// humble module\n"
-          "module foo (  // non-port comment\n"
-          "    // port comment 1\n"
-          "    // port comment 2\n"
-          ");  // header trailing comment\n"
-          "  // item comment 1\n"
-          "  // item comment 2\n"
-          "endmodule\n",
-      },
-
-      {
-          // module with comments around non-empty blocks
-          "  // humble module\n"
-          "  module foo (// non-port comment\n"
-          "// port comment 1\n"
-          "input   logic   f  \n"
-          "// port comment 2\n"
-          ");// header trailing comment\n"
-          "// item comment 1\n"
-          "wire w ; \n"
-          "// item comment 2\n"
-          "endmodule\n",
-          "// humble module\n"
-          "module foo (  // non-port comment\n"
-          "    // port comment 1\n"
-          "    input logic f\n"
-          "    // port comment 2\n"
-          ");  // header trailing comment\n"
-          "  // item comment 1\n"
-          "  wire w;\n"
-          "  // item comment 2\n"
-          "endmodule\n",
-      },
-  };
-  FormatStyle style;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-static constexpr FormatterTestCase kFormatterTestCasesElseStatements[] = {
-    {"module m;"
-     "task static t; if (r == t) a.b(c); else d.e(f); endtask;"
-     "endmodule",
-     "module m;\n"
-     "  task static t;\n"
-     "    if (r == t) a.b(c);\n"
-     "    else d.e(f);\n"
-     "  endtask\n"
-     "  ;\n"  // possibly unintended stray ';'
-     "endmodule\n"},
-    {"module m;"
-     "task static t; if (r == t) begin a.b(c); end else begin d.e(f); end "
-     "endtask;"
-     "endmodule",
-     "module m;\n"
-     "  task static t;\n"
-     "    if (r == t) begin\n"
-     "      a.b(c);\n"
-     "    end else begin\n"
-     "      d.e(f);\n"
-     "    end\n"
-     "  endtask\n"
-     "  ;\n"  // stray ';'
-     "endmodule\n"},
-    {"module m;initial begin if(a==b)"
-     "c.d(e);else\n"
-     "f.g(h);end endmodule",
-     "module m;\n"
-     "  initial begin\n"
-     "    if (a == b) c.d(e);\n"
-     "    else f.g(h);\n"
-     "  end\n"
-     "endmodule\n"},
-    {"   module m;  always_comb    begin     \n"
-     "        if      ( a   ) b =  16'hdead    ; \n"
-     "  else if (   c     )  d= 16 'hbeef  ;   \n"
-     "     else        if (e) f=16'hca_fe ;     \n"
-     "end   \n endmodule\n",
-     "module m;\n"
-     "  always_comb begin\n"
-     "    if (a) b = 16'hdead;\n"
-     "    else if (c) d = 16'hbeef;\n"
-     "    else if (e) f = 16'hca_fe;\n"
-     "  end\n"
-     "endmodule\n"},
-    {"module foo();\n"
-     "always_comb begin\n"
-     "value = function_name(.long_parameter(8'hA), .parameter_three(foobar));\n"
-     "end\n"
-     "endmodule : foo\n",
-     "module foo ();\n"
-     "  always_comb begin\n"
-     "    value = function_name(\n"
-     "      .long_parameter(8'hA),\n"
-     "      .parameter_three(foobar)\n"
-     "    );\n"
-     "  end\n"
-     "endmodule : foo\n"},
-    {"module foo();\n"
-     "always_comb begin\n"
-     "value = function_name(.a(1), .b(2));\n"
-     "end\n"
-     "endmodule : foo\n",
-     "module foo ();\n"
-     "  always_comb begin\n"
-     "    value = function_name(.a(1), .b(2));\n"
-     "  end\n"
-     "endmodule : foo\n"},
-    {"module foo ();\n"
-     "always_comb begin\n"
-     "value = function_name(8'hA, foobar, signal_1234); end\n"
-     "always_comb begin\n"
-     "value = function_name(8'hA, foobar); end\n"
-     "endmodule : foo\n",
-     "module foo ();\n"
-     "  always_comb begin\n"
-     "    value = function_name(8'hA, foobar,\n"
-     "                          signal_1234);\n"
-     "  end\n"
-     "  always_comb begin\n"
-     "    value = function_name(8'hA, foobar);\n"
-     "  end\n"
-     "endmodule : foo\n"},
-    {"module foo ();\n"
-     "always_comb begin\n"
-     "value = function_name(8'hA, foobar, signal_1234);\n"
-     "value = function_name(8'hA, foobar, signal_1234); end\n"
-     "endmodule : foo\n",
-     "module foo ();\n"
-     "  always_comb begin\n"
-     "    value = function_name(8'hA, foobar,\n"
-     "                          signal_1234);\n"
-     "    value = function_name(8'hA, foobar,\n"
-     "                          signal_1234);\n"
-     "  end\n"
-     "endmodule : foo\n"},
-    {"always_comb begin\n"
-     "value = "
-     "f(long_parameter_exceeding_col_limit, foo, bar); end\n",
-     "always_comb begin\n"
-     "  value = f(\n"
-     "    long_parameter_exceeding_col_limit,\n"
-     "    foo,\n"
-     "    bar\n"
-     "  );\n"
-     "end\n"},
-    {"module foo();\n"
-     "always_comb begin\n"
-     "value = function_name(8'hA, .parameter_three(foobar));\n"
-     "end\n"
-     "endmodule : foo\n",
-     "module foo ();\n"
-     "  always_comb begin\n"
-     "    value = function_name(\n"
-     "      8'hA,\n"
-     "      .parameter_three(foobar)\n"
-     "    );\n"
-     "  end\n"
-     "endmodule : foo\n"},
-    {"module foo ();\n"
-     "always_comb begin\n"
-     "value = function_name(8'hA, 8'hB, 8'hC, .parameter_four(foo), "
-     ".par_five(bar));\n"
-     "end\n"
-     "endmodule : foo\n",
-     "module foo ();\n"
-     "  always_comb begin\n"
-     "    value = function_name(\n"
-     "      8'hA,\n"
-     "      8'hB,\n"
-     "      8'hC,\n"
-     "      .parameter_four(foo),\n"
-     "      .par_five(bar)\n"
-     "    );\n"
-     "  end\n"
-     "endmodule : foo\n"},
-    {"class dv_base_mem; function void configure(); \nbegin\n"
-     "value = func(8'hA, foobar, signal_1234);\n"
-     "value = new(8'hA, foobar, signal_1234); end\n"
-     "endfunction : configure endclass\n",
-     "class dv_base_mem;\n"
-     "  function void configure();\n"
-     "    begin\n"
-     "      value = func(8'hA, foobar,\n"
-     "                   signal_1234);\n"
-     "      value = new(8'hA, foobar,\n"
-     "                  signal_1234);\n"
-     "    end\n"
-     "  endfunction : configure\n"
-     "endclass\n"},
-    {"module m; initial begin\n"
-     "        if     (a||b)        c         = 1'b1;\n"
-     "d =        1'b1; if         (e)\n"
-     "begin f = 1'b0; end else begin\n"
-     "    g = h;\n"
-     "        end \n"
-     " i = 1'b1; "
-     "end endmodule\n",
-     "module m;\n"
-     "  initial begin\n"
-     "    if (a || b) c = 1'b1;\n"
-     "    d = 1'b1;\n"
-     "    if (e) begin\n"
-     "      f = 1'b0;\n"
-     "    end else begin\n"
-     "      g = h;\n"
-     "    end\n"
-     "    i = 1'b1;\n"
-     "  end\n"
-     "endmodule\n"},
-    {"module m; initial begin\n"
-     "if (a&&b&&c) begin\n"
-     "         d         = 1'b1;\n"
-     "     if (e) begin\n"
-     "   f = ff;\n"
-     "       end  else   if  (    g  )   begin\n"
-     "     h = hh;\n"
-     "end else if (i) begin\n"
-     "    j   =   (kk == ll) ? mm :\n"
-     "      gg;\n"
-     "   end     else   if    (  qq )  begin\n"
-     "    if      (  xx   ||yy        ) begin    d0 = 1'b0;   d1   =       "
-     "1'b1;\n"
-     "  end else if (oo) begin aa =    bb; cc      = dd;"
-     "         if (zz) zx = xz; else ba = ab;"
-     "    end   else  \n begin      vv   =  tt  ;  \n"
-     "   end   end "
-     "end \n  else if   (uu)\nbegin\n\na=b;if (aa)   b =    c;\n"
-     "\nelse    if    \n (bb) \n\nc        =d    ;\n\n\n\n\n    "
-     "      else         e\n\n   =   h;\n\n"
-     "end \n  else    \n  begin if(x)y=a;else\nbegin\n"
-     "\n\n\na=y; if (a)       b     = c;\n\n\n\nelse\n\n\nd=e;end \n"
-     "end\n"
-     "end endmodule\n",
-     "module m;\n"
-     "  initial begin\n"
-     "    if (a && b && c) begin\n"
-     "      d = 1'b1;\n"
-     "      if (e) begin\n"
-     "        f = ff;\n"
-     "      end else if (g) begin\n"
-     "        h = hh;\n"
-     "      end else if (i) begin\n"
-     "        j = (kk == ll) ? mm : gg;\n"
-     "      end else if (qq) begin\n"
-     "        if (xx || yy) begin\n"
-     "          d0 = 1'b0;\n"
-     "          d1 = 1'b1;\n"
-     "        end else if (oo) begin\n"
-     "          aa = bb;\n"
-     "          cc = dd;\n"
-     "          if (zz) zx = xz;\n"
-     "          else ba = ab;\n"
-     "        end else begin\n"
-     "          vv = tt;\n"
-     "        end\n"
-     "      end\n"
-     "    end else if (uu) begin\n\n"
-     "      a = b;\n"
-     "      if (aa) b = c;\n\n"
-     "      else if (bb) c = d;\n\n\n\n\n"
-     "      else e = h;\n\n"
-     "    end else begin\n"
-     "      if (x) y = a;\n"
-     "      else begin\n\n\n\n"
-     "        a = y;\n"
-     "        if (a) b = c;\n\n\n\n"
-     "        else d = e;\n"
-     "      end\n"
-     "    end\n"
-     "  end\n"
-     "endmodule\n"}};
-
-TEST(FormatterEndToEndTest, FormatElseStatements) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  for (const auto &test_case : kFormatterTestCasesElseStatements) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, ConstraintExpressions) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {"", ""},
-
-      // class members
-      {"class Foo; constraint if_c { if (zzzzzzzzzzzzzzzzzzzzz)"
-       "{ soft xxxxxxxxxxxxxxxxxxxxxx == yyyyyyyyyyyyyyyyyyy; } } endclass",
-       "class Foo;\n"
-       "  constraint if_c {\n"
-       "    if (zzzzzzzzzzzzzzzzzzzzz) {\n"
-       "      soft xxxxxxxxxxxxxxxxxxxxxx == yyyyyyyyyyyyyyyyyyy;\n"
-       "    }\n"
-       "  }\n"
-       "endclass\n"},
-
-      // constraints with if-constraint expressions
-      {"constraint xx { if (a) b; }\n", "constraint xx {if (a) b;}\n"},
-
-      {"constraint xx { if (a) {b;} }\n",
-       "constraint xx {\n"
-       "  if (a) {\n"
-       "    b;\n"
-       "  }\n"
-       "}\n"},
-
-      // multi item constraint
-      {"constraint yy { a == b;c==d;}",
-       "constraint yy {\n"
-       "  a == b;\n"
-       "  c == d;\n"
-       "}\n"},
-
-      // one-line constraints
-      {"constraint only_vec_instr_c {soft only_vec_instr == 0;}",
-       "constraint only_vec_instr_c {soft only_vec_instr == 0;}\n"},
-
-      {"constraint\nnum_trans_c\n\n\n{\n\n\nnum_trans inside{[800:1000]};}",
-       "constraint num_trans_c {num_trans inside {[800 : 1000]};}\n"},
-
-      // if-vs-concatenation expression
-      {"constraint c_operation{  if(fixed_operation_en){"
-       "aes_operation == fixed_operation"
-       ";}}",
-       "constraint c_operation {\n"
-       "  if (fixed_operation_en) {\n"
-       "    aes_operation == fixed_operation;\n"
-       "  }\n"
-       "}\n"},
-
-      {"constraint c_operation{  if(fixed_operation_en){"
-       "aes_operation == fixed_operation"
-       "};}",
-       "constraint c_operation {\n"
-       "  if (fixed_operation_en)\n"
-       "  {aes_operation == fixed_operation};\n"
-       "}\n"},
-
-      // concatenation expression
-      {"constraint c_iv {if (fixed_iv_en) {aes_iv == fixed_iv};}",
-       "constraint c_iv {\n"
-       "  if (fixed_iv_en)\n"
-       "  {aes_iv == fixed_iv};\n"
-       "}\n"},
-
-      // looooong test
-      {"constraint xx {"
-       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)"
-       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=="
-       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"
-       "ccccccccccccccccccccccc==dddddddddddddddddddddd;}",
-       "constraint xx {\n"
-       "  if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == "
-       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;\n"
-       "  ccccccccccccccccccccccc == dddddddddddddddddddddd;\n"
-       "}\n"},
-  };
-  FormatStyle style;
-  style.column_limit =
-      100;  // smaller column_limit forces expansion of constraint blocks
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.port_declarations_alignment = verible::AlignmentPolicy::kPreserve;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-static constexpr FormatterTestCase kFormatterTestCasesEnumDeclarations[] = {
-    // Inferring user intent: not too many spaces to be added: align.
-    {"typedef enum { kA=1, kAB=2, kABC=3} x;",
-     "typedef enum {\n"
-     "  kA   = 1,\n"
-     "  kAB  = 2,\n"
-     "  kABC = 3\n} x;\n"},
-
-    // Lots of spaces would've to be be added - keep flush
-    {"typedef enum { kA=1, kAB=2, kABCDEFGHIJKLMN=3} x;",
-     "typedef enum {\n"
-     "  kA = 1,\n"
-     "  kAB = 2,\n"
-     "  kABCDEFGHIJKLMN = 3\n} x;\n"},
-
-    // Source spaces indicate alignment wish.
-    {"typedef enum { kA     =1, kAB=2, kABCDEFGHIJKLMN=3} x;",
-     "typedef enum {\n"
-     "  kA              = 1,\n"
-     "  kAB             = 2,\n"
-     "  kABCDEFGHIJKLMN = 3\n} x;\n"},
-
-    // An empty line groups into several sections, to be aligned independently
-    {"typedef enum { kA=1, kAB=2, \n\n kABC=3} x;",
-     "typedef enum {\n"
-     "  kA  = 1,\n"
-     "  kAB = 2,\n"
-     "\n"
-     "  kABC = 3\n} x;\n"},
-
-    // Lines with comments don't interrupt alignment
-    {"typedef enum { kA=1,\n"
-     "// hello world\n"
-     "kAB=2, kABC=3} x;",
-     "typedef enum {\n"
-     "  kA   = 1,\n"
-     "  // hello world\n"
-     "  kAB  = 2,\n"
-     "  kABC = 3\n} x;\n"},
-
-    // Generally, comment locations are preserved, and full line comments
-    // indented to enum name level.
-    {"typedef enum { kA=1,// value kA\n"
-     "// hello world\n"
-     "kAB=2,// value kAB\n"
-     "kABC=3// value kABC\n"
-     "} x;",
-     "typedef enum {\n"
-     "  kA   = 1,  // value kA\n"
-     "  // hello world\n"
-     "  kAB  = 2,  // value kAB\n"
-     "  kABC = 3   // value kABC"
-     "\n} x;\n"},
-
-    {"typedef enum { kA=1,// value kA\n"
-     "kAB=2,\n"
-     "kABC=3// value kABC\n"
-     "} x;",
-     "typedef enum {\n"
-     "  kA   = 1,  // value kA\n"
-     "  kAB  = 2,\n"
-     "  kABC = 3   // value kABC"
-     "\n} x;\n"},
-
-    // Numeric constants are currently flushed left, but maybe todo
-    // align right in the future ?
-    {"typedef enum { kA=1, kAB=10, kABC=100} x;",
-     "typedef enum {\n"
-     "  kA   = 1,\n"
-     "  kAB  = 10,\n"
-     "  kABC = 100\n} x;\n"},
-};
-
-TEST(FormatterEndToEndTest, FormatAlignEnumDeclarations) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.enum_assignment_statement_alignment = AlignmentPolicy::kInferUserIntent;
-  for (const auto &test_case : kFormatterTestCasesEnumDeclarations) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, DiagnosticShowFullTree) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  for (const auto &test_case : kFormatterTestCases) {
-    std::ostringstream stream, debug_stream;
-    ExecutionControl control;
-    control.stream = &debug_stream;
-    control.show_token_partition_tree = true;
-    const auto status = FormatVerilog(test_case.input, "<filename>", style,
-                                      stream, kEnableAllLines, control);
-    EXPECT_EQ(status.code(), StatusCode::kCancelled);
-    EXPECT_TRUE(
-        absl::StartsWith(debug_stream.str(), "Full token partition tree"));
-  }
-}
-
-TEST(FormatterEndToEndTest, DiagnosticLargestPartitions) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  for (const auto &test_case : kFormatterTestCases) {
-    std::ostringstream stream, debug_stream;
-    ExecutionControl control;
-    control.stream = &debug_stream;
-    control.show_largest_token_partitions = 2;
-    const auto status = FormatVerilog(test_case.input, "<filename>", style,
-                                      stream, kEnableAllLines, control);
-    EXPECT_EQ(status.code(), StatusCode::kCancelled);
-    EXPECT_TRUE(absl::StartsWith(debug_stream.str(), "Showing the "))
-        << "got: " << debug_stream.str();
-  }
-}
-
-TEST(FormatterEndToEndTest, DiagnosticEquallyOptimalWrappings) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  for (const auto &test_case : kFormatterTestCases) {
-    std::ostringstream stream, debug_stream;
-    ExecutionControl control;
-    control.stream = &debug_stream;
-    control.show_equally_optimal_wrappings = true;
-    const auto status = FormatVerilog(test_case.input, "<filename>", style,
-                                      stream, kEnableAllLines, control);
-    EXPECT_OK(status) << status.message();
-    if (!debug_stream.str().empty()) {
-      EXPECT_TRUE(absl::StartsWith(debug_stream.str(), "Showing the "))
-          << "got: " << debug_stream.str();
-      // Cannot guarantee among unit tests that there will be >1 solution.
-    }
-  }
-}
-
-// Test that hitting search space limit results in correct error status.
-TEST(FormatterEndToEndTest, UnfinishedLineWrapSearching) {
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-
-  const std::string_view code("parameter int x = 1+1;\n");
-
-  std::ostringstream stream, debug_stream;
-  ExecutionControl control;
-  control.max_search_states = 2;  // Cause search to abort early.
-  control.stream = &debug_stream;
-  const auto status = FormatVerilog(code, "<filename>", style, stream,
-                                    kEnableAllLines, control);
-  EXPECT_EQ(status.code(), StatusCode::kResourceExhausted);
-  EXPECT_TRUE(absl::StartsWith(status.message(), "***"));
-}
-
-static constexpr FormatterTestCase kOnelineFormatBaselineTestCases[] = {
-    // Reference - following test cases should not be affected by the switch
-    {// Minimal useful case
-     "covergroup c @ (posedge clk); coverpoint a; endgroup\n",
-     "covergroup c @(posedge clk);\n"
-     "  coverpoint a;\n"
-     "endgroup\n"},
-    {// Multiple coverpoints
-     "covergroup foo @(posedge clk); coverpoint a; coverpoint b; "
-     "coverpoint c; coverpoint d; endgroup\n",
-     "covergroup foo @(posedge clk);\n"
-     "  coverpoint a;\n"
-     "  coverpoint b;\n"
-     "  coverpoint c;\n"
-     "  coverpoint d;\n"
-     "endgroup\n"},
-    {// Multiple bins
-     "covergroup memory @ (posedge ce); address  :coverpoint addr {"
-     "bins low={LOW}; bins high={HIGH};} endgroup\n",
-     "covergroup memory @(posedge ce);\n"
-     "  address: coverpoint addr {\n"
-     "    bins low = {LOW};\n"
-     "    bins high = {HIGH};\n"
-     "  }\n"
-     "endgroup\n"},
-    {// Multiple bins with multiple elements
-     "covergroup memory @ (posedge ce); address  :coverpoint addr {"
-     "bins low={0,127}; bins high={128,255};} endgroup\n",
-     "covergroup memory @(posedge ce);\n"
-     "  address: coverpoint addr {\n"
-     "    bins low = {0, 127};\n"
-     "    bins high = {128, 255};\n"
-     "  }\n"
-     "endgroup\n"},
-};
-
-// Tests that constructs that could be formatted as one-liners are formatted
-// correctly. This is the baseline test with default style, test cases should
-// not be affected by the setting.
-TEST(FormatterEndToEndTest, OnelineFormatBaselineTest) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.expand_coverpoints = false;
-  for (const auto &test_case : kOnelineFormatBaselineTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-  // Test again with the switch, should not affect formatting
-  style.expand_coverpoints = true;
-  for (const auto &test_case : kOnelineFormatBaselineTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Following two test sets are affected by the expand_coverponits switch
-// They should contain corresponding test cases
-static constexpr FormatterTestCase kOnelineFormatReferenceTestCases[] = {
-    {// Coverpoint that could fit on one line
-     "covergroup memory @ (posedge ce); a :coverpoint d {"
-     "bins l={0};} endgroup\n",
-     "covergroup memory @(posedge ce);\n"
-     "  a: coverpoint d {bins l = {0};}\n"
-     "endgroup\n"},
-    {// Fit with a reference
-     "covergroup memory @ (posedge ce); a :coverpoint d {"
-     "bins l={LOW};} endgroup\n",
-     "covergroup memory @(posedge ce);\n"
-     "  a: coverpoint d {bins l = {LOW};}\n"
-     "endgroup\n"},
-    {// Fit with multiple elements
-     "covergroup memory @ (posedge ce); a :coverpoint d {"
-     "bins l={0,8};} endgroup\n",
-     "covergroup memory @(posedge ce);\n"
-     "  a: coverpoint d {bins l = {0, 8};}\n"
-     "endgroup\n"},
-};
-
-static constexpr FormatterTestCase kOnelineFormatExpandTestCases[] = {
-    {// Coverpoint that could fit on one line
-     "covergroup memory @ (posedge ce); a :coverpoint d {"
-     "bins l={0};} endgroup\n",
-     "covergroup memory @(posedge ce);\n"
-     "  a: coverpoint d {\n"
-     "    bins l = {0};\n"
-     "  }\n"
-     "endgroup\n"},
-    {// Fit with a reference
-     "covergroup memory @ (posedge ce); a :coverpoint d {"
-     "bins l={LOW};} endgroup\n",
-     "covergroup memory @(posedge ce);\n"
-     "  a: coverpoint d {\n"
-     "    bins l = {LOW};\n"
-     "  }\n"
-     "endgroup\n"},
-    {// Fit with multiple elements
-     "covergroup memory @ (posedge ce); a :coverpoint d {"
-     "bins l={0,8};} endgroup\n",
-     "covergroup memory @(posedge ce);\n"
-     "  a: coverpoint d {\n"
-     "    bins l = {0, 8};\n"
-     "  }\n"
-     "endgroup\n"},
-};
-
-TEST(FormatterEndToEndTest, OnelineFormatReferenceTest) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.expand_coverpoints = false;
-
-  for (const auto &test_case : kOnelineFormatReferenceTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Tests that constructs that could be formatted as one-liners are expanded
-// correctly. This is the baseline test with default style
-TEST(FormatterEndToEndTest, OnelineFormatExpandTest) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.expand_coverpoints = true;
-
-  for (const auto &test_case : kOnelineFormatExpandTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-struct DimensionsAlignmentTestCase {
-  std::string_view input;
-  std::string_view expected[4];
-};
-
-static constexpr DimensionsAlignmentTestCase
-    kPortDeclarationDimensionsAlignmentTestCases[] = {
-        {"import \"DPI-C\" context function void func(\n"
-         "input bit foo,\n"
-         "input bit [2] foobar,\n"
-         "input bit [24:16] bar,\n"
-         "input bit [2:0][31:0] baz,\n"
-         "input bit [4][24:0][16:0] foobarbaz[],\n"
-         "input bit [FOOBAZ][31:24] qux[16],\n"
-         "input bit [16] quux[8:2][16][32],\n"
-         "output bit [2:0][2:0][2:0] quuz[8][16:12]\n"
-         ");\n",
-         {
-             "import \"DPI-C\" context function void func(\n"
-             "  input  bit                       foo,\n"
-             "  input  bit [     2]              foobar,\n"
-             "  input  bit [ 24:16]              bar,\n"
-             "  input  bit [   2:0][ 31:0]       baz,\n"
-             "  input  bit [     4][ 24:0][16:0] foobarbaz[   ],\n"
-             "  input  bit [FOOBAZ][31:24]       qux      [ 16],\n"
-             "  input  bit [    16]              quux     [8:2][   16][32],\n"
-             "  output bit [   2:0][  2:0][ 2:0] quuz     [  8][16:12]\n"
-             ");\n",
-             "import \"DPI-C\" context function void func(\n"
-             "  input  bit                       foo,\n"
-             "  input  bit [     2]              foobar,\n"
-             "  input  bit [ 24:16]              bar,\n"
-             "  input  bit [   2:0][ 31:0]       baz,\n"
-             "  input  bit [     4][ 24:0][16:0] foobarbaz         [     ],\n"
-             "  input  bit [FOOBAZ][31:24]       qux               [   16],\n"
-             "  input  bit [    16]              quux     [8:2][16][   32],\n"
-             "  output bit [   2:0][  2:0][ 2:0] quuz          [ 8][16:12]\n"
-             ");\n",
-             "import \"DPI-C\" context function void func(\n"
-             "  input  bit                      foo,\n"
-             "  input  bit              [    2] foobar,\n"
-             "  input  bit              [24:16] bar,\n"
-             "  input  bit      [   2:0][ 31:0] baz,\n"
-             "  input  bit [  4][  24:0][ 16:0] foobarbaz[   ],\n"
-             "  input  bit      [FOOBAZ][31:24] qux      [ 16],\n"
-             "  input  bit              [   16] quux     [8:2][   16][32],\n"
-             "  output bit [2:0][   2:0][  2:0] quuz     [  8][16:12]\n"
-             ");\n",
-             "import \"DPI-C\" context function void func(\n"
-             "  input  bit                      foo,\n"
-             "  input  bit              [    2] foobar,\n"
-             "  input  bit              [24:16] bar,\n"
-             "  input  bit      [   2:0][ 31:0] baz,\n"
-             "  input  bit [  4][  24:0][ 16:0] foobarbaz         [     ],\n"
-             "  input  bit      [FOOBAZ][31:24] qux               [   16],\n"
-             "  input  bit              [   16] quux     [8:2][16][   32],\n"
-             "  output bit [2:0][   2:0][  2:0] quuz          [ 8][16:12]\n"
-             ");\n",
-         }},
-        {"module m(\n"
-         "output bit [2:0][2:0][2:0] quuz[8][16:12],\n"
-         "input bit [16] quux[8:2][16][32],\n"
-         "input bit [FOOBAZ][31:24] qux[16],\n"
-         "input bit [4][24:0][16:0] foobaz[],\n"
-         "input bit [2:0][31:0] baz,\n"
-         "input bit [24:16] bar,\n"
-         "input bit [2] foobar,\n"
-         "input bit foo\n"
-         "); endmodule:m\n",
-         {
-             "module m (\n"
-             "    output bit [   2:0][  2:0][ 2:0] quuz  [  8][16:12],\n"
-             "    input  bit [    16]              quux  [8:2][   16][32],\n"
-             "    input  bit [FOOBAZ][31:24]       qux   [ 16],\n"
-             "    input  bit [     4][ 24:0][16:0] foobaz[   ],\n"
-             "    input  bit [   2:0][ 31:0]       baz,\n"
-             "    input  bit [ 24:16]              bar,\n"
-             "    input  bit [     2]              foobar,\n"
-             "    input  bit                       foo\n"
-             ");\n"
-             "endmodule : m\n",
-             "module m (\n"
-             "    output bit [   2:0][  2:0][ 2:0] quuz       [ 8][16:12],\n"
-             "    input  bit [    16]              quux  [8:2][16][   32],\n"
-             "    input  bit [FOOBAZ][31:24]       qux            [   16],\n"
-             "    input  bit [     4][ 24:0][16:0] foobaz         [     ],\n"
-             "    input  bit [   2:0][ 31:0]       baz,\n"
-             "    input  bit [ 24:16]              bar,\n"
-             "    input  bit [     2]              foobar,\n"
-             "    input  bit                       foo\n"
-             ");\n"
-             "endmodule : m\n",
-             "module m (\n"
-             "    output bit [2:0][   2:0][  2:0] quuz  [  8][16:12],\n"
-             "    input  bit              [   16] quux  [8:2][   16][32],\n"
-             "    input  bit      [FOOBAZ][31:24] qux   [ 16],\n"
-             "    input  bit [  4][  24:0][ 16:0] foobaz[   ],\n"
-             "    input  bit      [   2:0][ 31:0] baz,\n"
-             "    input  bit              [24:16] bar,\n"
-             "    input  bit              [    2] foobar,\n"
-             "    input  bit                      foo\n"
-             ");\n"
-             "endmodule : m\n",
-             "module m (\n"
-             "    output bit [2:0][   2:0][  2:0] quuz       [ 8][16:12],\n"
-             "    input  bit              [   16] quux  [8:2][16][   32],\n"
-             "    input  bit      [FOOBAZ][31:24] qux            [   16],\n"
-             "    input  bit [  4][  24:0][ 16:0] foobaz         [     ],\n"
-             "    input  bit      [   2:0][ 31:0] baz,\n"
-             "    input  bit              [24:16] bar,\n"
-             "    input  bit              [    2] foobar,\n"
-             "    input  bit                      foo\n"
-             ");\n"
-             "endmodule : m\n",
-         }},
-};
-
-TEST(FormatterEndToEndTest, PortDeclarationDimensionsAlignmentTest) {
-  FormatStyle style;
-  style.column_limit = 64;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-
-  // All combinations of port_declaration_right_align_{un,}packed_dimensions
-  static const bool right_align_combinations[][2] = {
-      {false, false}, {false, true}, {true, false}, {true, true}};
-
-  for (const auto &test_case : kPortDeclarationDimensionsAlignmentTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    size_t expected_index = 0;
-    for (const auto &right_align : right_align_combinations) {
-      VLOG(1) << "style variant:\n"
-              << "port_declarations_right_align_packed_dimensions: "
-              << right_align[0] << "\n"
-              << "port_declarations_right_align_unpacked_dimensions: "
-              << right_align[1] << "\n";
-      style.port_declarations_right_align_packed_dimensions = right_align[0];
-      style.port_declarations_right_align_unpacked_dimensions = right_align[1];
-
-      std::ostringstream stream;
-
-      const auto status =
-          FormatVerilog(test_case.input, "<filename>", style, stream);
-      // Require these test cases to be valid.
-      EXPECT_OK(status) << status.message();
-      EXPECT_EQ(stream.str(), test_case.expected[expected_index++])
-          << "code:\n"
-          << test_case.input;
-    }
-  }
-}
-
-// TODO(fangism): directed tests using style variations
-
-static constexpr FormatterTestCase kNestedFunctionsTestCases40ColumnsLimit[] = {
-    {"module foo;"
-     "`uvm_info(`gfn, $sformatf(\n"
-     "\"\\n  base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, "
-     "i), UVM_DEBUG)\n"
-     "endmodule",
-     "module foo;\n"
-     "  `uvm_info(\n"
-     "      `gfn,\n"
-     "      $sformatf(\n"
-     "          \"\\n  base_vseq: generate %0d pulse in channel %0d\",\n"
-     "          cfg.num_pulses, i), UVM_DEBUG)\n"
-     "endmodule\n"},
-    {"module foo;`uvm_info(`gfn, $sformatf("
-     "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\","
-     "cfg.convert2string()), UVM_LOW)\n"
-     "endmodule",
-     "module foo;\n"
-     "  `uvm_info(\n"
-     "      `gfn,\n"
-     "      $sformatf(\n"
-     "          \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\",\n"
-     "          cfg.convert2string()),\n"
-     "      UVM_LOW)\n"  // FIXME: Wrapped by SearchLineWraps
-     "endmodule\n"},
-};
-
-TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases40ColumnsLimit) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-
-  for (const auto &test_case : kNestedFunctionsTestCases40ColumnsLimit) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-static constexpr FormatterTestCase kNestedFunctionsTestCases60ColumnsLimit[] = {
-    {"module foo;"
-     "`uvm_info(`gfn, $sformatf(\n"
-     "\"\\n  base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, "
-     "i), UVM_DEBUG)\n"
-     "endmodule",
-     "module foo;\n"
-     "  `uvm_info(\n"
-     "      `gfn,\n"
-     "      $sformatf(\n"
-     "          \"\\n  base_vseq: generate %0d pulse in channel %0d\",\n"
-     "          cfg.num_pulses, i), UVM_DEBUG)\n"
-     "endmodule\n"},
-    {"module foo;`uvm_info(`gfn, $sformatf("
-     "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\","
-     "cfg.convert2string()), UVM_LOW)\n"
-     "endmodule",
-     "module foo;\n"
-     "  `uvm_info(\n"
-     "      `gfn,\n"
-     "      $sformatf(\n"
-     "          \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\",\n"
-     "          cfg.convert2string()), UVM_LOW)\n"
-     "endmodule\n"},
-};
-
-TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases60ColumnsLimit) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 60;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-
-  for (const auto &test_case : kNestedFunctionsTestCases60ColumnsLimit) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-static constexpr FormatterTestCase kNestedFunctionsTestCases80ColumnsLimit[] = {
-    {"module foo;"
-     "`uvm_info(`gfn, $sformatf(\n"
-     "\"\\n  base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, "
-     "i), UVM_DEBUG)\n"
-     "endmodule",
-     "module foo;\n"
-     "  `uvm_info(`gfn, $sformatf(\"\\n  base_vseq: generate %0d pulse in "
-     "channel %0d\",\n"
-     "                            cfg.num_pulses, i), UVM_DEBUG)\n"
-     "endmodule\n"},
-    {"module foo;`uvm_info(`gfn, $sformatf("
-     "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\","
-     "cfg.convert2string()), UVM_LOW)\n"
-     "endmodule",
-     "module foo;\n"
-     "  `uvm_info(`gfn, $sformatf(\n"
-     "                      \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE "
-     "|----\\n %s\",\n"
-     "                      cfg.convert2string()), UVM_LOW)\nendmodule\n"},
-    {"module x;"
-     "`uvm_fatal(`gfn, $sformatf("
-     "\"The data 0x%0h written to the signature address is formatted "
-     "incorrectly.\","
-     "signature_data))\n"
-     "endmodule",
-     "module x;\n"
-     "  `uvm_fatal(\n"
-     "      `gfn,\n"
-     "      $sformatf(\n"
-     "          \"The data 0x%0h written to the signature address is formatted "
-     "incorrectly.\",\n"
-     "          signature_data))\n"
-     "endmodule\n"},
-};
-
-TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases80ColumnsLimit) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 80;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-
-  for (const auto &test_case : kNestedFunctionsTestCases80ColumnsLimit) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-static constexpr FormatterTestCase kNestedFunctionsTestCases100ColumnsLimit[] =
-    {
-        {"module foo;"
-         "`uvm_info(`gfn, $sformatf(\n"
-         "\"\\n  base_vseq: generate %0d pulse in channel %0d\", "
-         "cfg.num_pulses, i), UVM_DEBUG)\n"
-         "endmodule",
-         "module foo;\n"
-         "  `uvm_info(`gfn, $sformatf(\"\\n  base_vseq: generate %0d pulse in "
-         "channel %0d\", cfg.num_pulses, i),\n"
-         "            UVM_DEBUG)\n"
-         "endmodule\n"},
-        {"module foo;`uvm_info(`gfn, $sformatf("
-         "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\","
-         "cfg.convert2string()), UVM_LOW)\n"
-         "endmodule",
-         "module foo;\n"
-         "  `uvm_info(`gfn, $sformatf(\"\\n\\n\\t ----| STARTING AES MAIN "
-         "SEQUENCE |----\\n %s\",\n"
-         "                            cfg.convert2string()), UVM_LOW)\n"
-         "endmodule\n"},
-        {"module x;"
-         "`uvm_fatal(`gfn, $sformatf("
-         "\"The data 0x%0h written to the signature address is formatted "
-         "incorrectly.\","
-         "signature_data))\n"
-         "endmodule",
-         "module x;\n"
-         "  `uvm_fatal(`gfn, $sformatf(\n"
-         "                       \"The data 0x%0h written to the signature "
-         "address is formatted incorrectly.\",\n"
-         "                       signature_data))\n"
-         "endmodule\n"},
-        {// nested modules, three-levels
-         "module x; module y; module z;"
-         "`uvm_fatal(`gfn, $sformatf("
-         "\"The data 0x%0h written to the signature address is formatted "
-         "incorrectly.\","
-         "signature_data))\n"
-         "endmodule endmodule endmodule",
-         "module x;\n"
-         "  module y;\n"
-         "    module z;\n"
-         "      `uvm_fatal(`gfn,\n"
-         "                 $sformatf(\n"
-         "                     \"The data 0x%0h written to the signature "
-         "address is formatted incorrectly.\",\n"
-         "                     signature_data))\n"
-         "    endmodule\n"
-         "  endmodule\n"
-         "endmodule\n"},
-};
-
-TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases100ColumnsLimit) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 100;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-
-  for (const auto &test_case : kNestedFunctionsTestCases100ColumnsLimit) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-static constexpr FormatterTestCase noCompactIndexingAndSelectionsTestCases[]{
-    {"module m1 ();\n"
-     "  assign s1 = msg[1 : 2 + 3];\n"
-     "  assign s2 = {<<8{msg[1 : 2 + 3]}};\n"
-     "endmodule\n",
-     "module m1 ();\n"
-     "  assign s1 = msg[1 : 2 + 3];\n"
-     "  assign s2 = {<< 8{msg[1 : 2 + 3]}};\n"
-     "endmodule\n"}};
-
-TEST(FormatterEndToEndTest, compactIndexingAndSelectionsTestCases) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 100;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.compact_indexing_and_selections = false;
-
-  for (const auto &test_case : noCompactIndexingAndSelectionsTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-static constexpr FormatterTestCase kFunctionCallsWithComments[] = {
-    {// no comments
-     "module foo;\n"
-     "`uvm_info(`gfn, \"xx\",\n"
-     "cfg.num_pulses, i, UVM_DEBUG)\n"
-     "endmodule",
-     "module foo;\n"
-     "  `uvm_info(`gfn, \"xx\", cfg.num_pulses, i, UVM_DEBUG)\n"
-     "endmodule\n"},
-    {// one comment
-     "module foo;\n"
-     "`uvm_info(`gfn, \"xx\",  // yy\n"
-     "cfg.num_pulses, i, UVM_DEBUG)\n"
-     "endmodule",
-     "module foo;\n"
-     "  `uvm_info(`gfn, \"xx\",  // yy\n"
-     "            cfg.num_pulses, i, UVM_DEBUG)\n"
-     "endmodule\n"},
-    {// two comments
-     "module foo;\n"
-     "`uvm_info(`gfn, \"xx\",  "
-     "    cfg.num_pulses, // xx\n"
-     " i, UVM_DEBUG)// uuu\n"
-     "endmodule",
-     "module foo;\n"
-     "  `uvm_info(`gfn, \"xx\", cfg.num_pulses,  // xx\n"
-     "            i, UVM_DEBUG)  // uuu\n"
-     "endmodule\n"},
-
-    {// nested function calls with comments
-     "module foo;"
-     "`uvm_info(`gfn, $sformatf(\"\\n  base_vseq: generate %0d"
-     " pulse in channel %0d\", cfg.num_pulses, // comment\n"
-     " i), UVM_DEBUG)\n"
-     "endmodule",
-     "module foo;\n"
-     "  `uvm_info(`gfn, $sformatf(\"\\n  base_vseq: generate %0d pulse in "
-     "channel %0d\",\n"
-     "                            cfg.num_pulses,  // comment\n"
-     "                            i), UVM_DEBUG)\n"
-     "endmodule\n"},
-};
-
-TEST(FormatterEndToEndTest, FunctionCallsWithComments) {
-  // Use a fixed style.
-  FormatStyle style;
-  style.column_limit = 100;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-
-  for (const auto &test_case : kFunctionCallsWithComments) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    // Require these test cases to be valid.
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Extracts the first non-whitespace token and prepends it with number of
-// of newlines seen in front of it. So "\n \n\n  foo" -> "3foo"
-std::string NLCountAndfirstWord(std::string_view str) {
-  std::string result;
-  int newline_count = 0;
-  std::string_view::const_iterator begin = str.begin();
-  for (/**/; begin < str.end(); ++begin) {
-    if (!isspace(*begin)) break;
-    newline_count += (*begin == '\n');
-  }
-  // Emit number of newlines seen up to first token.
-  result.append(1,
-                static_cast<char>(newline_count + '0'));  // single digit itoa
-  std::string_view::const_iterator end_str = begin;
-  for (/**/; end_str < str.end() && !isspace(*end_str); ++end_str) {
-  }
-  result.append(begin, end_str);
-  return result;
-}
-
-// Similar to NLCountAndfirstWord() but looking at the last token and trailing
-// newlines.
-std::string lastWordAndNLCount(std::string_view str) {
-  std::string result;
-  int newline_count = 0;
-  std::string_view::const_iterator back = str.end() - 1;
-  for (/**/; back >= str.begin(); --back) {
-    if (!isspace(*back)) break;
-    newline_count += (*back == '\n');
-  }
-
-  std::string_view::const_iterator start_str = back;
-  for (/**/; start_str >= str.begin() && !isspace(*start_str); --start_str) {
-  }
-  result.append(&*(start_str + 1), back - start_str);
-  // Emit number of newlines seen following last token.
-  result.append(1,
-                static_cast<char>(newline_count + '0'));  // single digit itoa
-  return result;
-}
-
-// Testing the tester...
-TEST(FormatterTestInternal, TokenExtractorAndLineCounterTestFixtureTest) {
-  std::string_view str = "\n \nhello world \n \n";
-  ASSERT_EQ(NLCountAndfirstWord(str), "2hello");
-  ASSERT_EQ(NLCountAndfirstWord(str.substr(1)), "1hello");
-  ASSERT_EQ(NLCountAndfirstWord(str.substr(3)), "0hello");
-
-  ASSERT_EQ(lastWordAndNLCount(str), "world2");
-  ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 1)), "world1");
-  ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 2)), "world1");
-  ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 3)), "world0");
-
-  str = "aworld \n \n";  // Make sure to not overshoot begin.
-  ASSERT_EQ(lastWordAndNLCount(str.substr(1)), "world2");
-}
-
-TEST(FormatterEndToEndTest, RangeFormattingOnlyEmittingRelevantLines) {
-  // Including some empty lines to make sure the formatting
-  static constexpr std::string_view unformatted =
-      R"(     module foo (// non-port comment
-
-     // some comment
-
-  input  logic  a, input logic  b,input bit [2]
-foobar, input    bit [4] foobaz,
-    input bit [2]    quux
-
-
-        ); endmodule
-)";
-
-  std::vector<std::string_view> lines = absl::StrSplit(unformatted, '\n');
-  const int kLineCount = lines.size();
-
-  FormatStyle style;
-
-  // Go through all possible sub-ranges, format these, and compare that the
-  // output of the range output is contained inside the full format given the
-  // same sub-range.
-  for (int start_line = 0; start_line < kLineCount; ++start_line) {
-    for (int end_line = start_line; end_line < kLineCount; ++end_line) {
-      // Line numbers are 1-index based.
-      const verible::Interval<int> range = {start_line + 1, end_line + 1};
-
-      // Format full text for reference
-      std::ostringstream full_format;
-      absl::Status status =
-          FormatVerilog(unformatted, "<filename>", style, full_format, {range});
-      EXPECT_OK(status) << status.message();
-
-      // To test: range formatted.
-      std::string range_formatted;
-      status = FormatVerilogRange(unformatted, "<filename>", style,
-                                  &range_formatted, range);
-      EXPECT_OK(status) << status.message();
-      if (range.empty()) {  // Nothing to format: expect empty output.
-        EXPECT_TRUE(range_formatted.empty());
-        continue;
-      }
-
-      // Area we cover in the input (include the final newline);
-      const auto source_begin = lines[start_line].begin();
-      const auto source_end = lines[end_line - 1].end() + 1;  // include \n
-      const std::string_view range_unformatted(&*source_begin,
-                                               source_end - source_begin);
-
-      // To compare that we indeed formatted the requested reqgion, we make
-      // sure that the first and last token (simplified: non-whitespace word)
-      // in the input of the range to be formatted is
-      // exactly the first and last token that comes out of the range
-      // formatted snippet.
-      //
-      // While the whitespace might be different at the beginning and end
-      // due to formatting, the number of _newlines_ at the beginning and end
-      // should be the same, so we include the newline count in the comparison.
-
-      EXPECT_EQ(NLCountAndfirstWord(range_unformatted),
-                NLCountAndfirstWord(range_formatted))
-          << "'" << range_unformatted << "' vs. '" << range_formatted << "'";
-
-      // ... same for the last word.
-      EXPECT_EQ(lastWordAndNLCount(range_unformatted),
-                lastWordAndNLCount(range_formatted))
-          << "'" << range_unformatted << "' vs. '" << range_formatted << "'";
-
-      EXPECT_LE(range_formatted.length(), full_format.str().length());
-      EXPECT_THAT(full_format.str(), HasSubstr(range_formatted));
-    }
-  }
-}
-
-// Creates a string_view spanning a whole string literal.
-// Works correctly with strings containing null bytes.
-template <std::size_t N>
-constexpr std::string_view string_view_from_literal(const char (&s)[N]) {
-  return std::string_view(s, N - 1);
-}
-
-// The following regressions have been found by a fuzzer, so the input might
-// look a bit 'funny'. Nevertheless, they expose real bugs in the code.
-
-[[maybe_unused]] void TestForNonCrash(std::string_view input) {
-  using verible::EscapeString;
-  FormatStyle style;
-  std::ostringstream stream;
-  const auto status = FormatVerilog(input, "<filename>", style, stream);
-  // If we are here, we did at least not crash, which is all we desire for
-  // the fuzzer tests.
-  // Other issues that are reported correctly (probably due to strange inputs
-  // generated by the fuzzer) are ok, so we just log them here FYI.
-  if (!status.ok()) {
-    LOG(INFO) << "No crash, but format failed for other reason: "
-              << status.message() << "\nEscaped input: \""
-              << EscapeString(input) << "\"";
-  }
-}
-
-#if 0
-// https://github.com/chipsalliance/verible/issues/1381
-TEST(FormatterEndToEndTest, FuzzingRegression_1381) {
-  TestForNonCrash(string_view_from_literal("P#(\0\0//\0//\0,);"));
-  TestForNonCrash(string_view_from_literal("P#(\0\0//\0,,//\0,"));
-}
-#endif
-
-// https://github.com/chipsalliance/verible/issues/1384
-TEST(FormatterEndToEndTest, FuzzingRegression_UseAfterFree_1384) {
-  TestForNonCrash("`c(`c(//););");
-}
-
-// https://github.com/chipsalliance/verible/issues/1386
-TEST(FormatterEndToEndTest, FuzzingRegressionHierachyInvariant) {
-  // Original sample input from fuzzer
-  TestForNonCrash(string_view_from_literal("`c(`c()\0;);"));
-  // Lexically correct variant (`\0` -> `\n`)
-  TestForNonCrash(string_view_from_literal("`c(`c()\n;);"));
-  // Lexically correct variant (`\0` removed)
-  TestForNonCrash(string_view_from_literal("`c(`c(););"));
-}
-
-// Possibly same ? https://github.com/chipsalliance/verible/issues/1386
-TEST(FormatterEndToEndTest, FuzzingRegression_outofmemory) {
-  TestForNonCrash(string_view_from_literal("`f(1'O`f())\n"));
-}
-
-TEST(FormatterEndToEndTest, AlignmentGroupBoundaryNone) {
-  // Default behavior: separator comments and blank lines do NOT break groups.
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// Separator comment does not break alignment group
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "// ============\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo    = 1'b1;\n"
-       "  assign baar   = 1'b0;\n"
-       "  // ============\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.alignment_group_boundary = AlignmentGroupBoundary::kNone;
-  style.assignment_statement_alignment = AlignmentPolicy::kAlign;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, AlignmentGroupBoundarySeparatorComments) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// Separator comment breaks alignment group
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "// ============\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo  = 1'b1;\n"
-       "  assign baar = 1'b0;\n"
-       "  // ============\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// Dashes separator also breaks
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "// ------------\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo  = 1'b1;\n"
-       "  assign baar = 1'b0;\n"
-       "  // ------------\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// Captioned divider (text between separator runs) also breaks
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "// ------ section heading ------\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo  = 1'b1;\n"
-       "  assign baar = 1'b0;\n"
-       "  // ------ section heading ------\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// Leading-only divider run with trailing caption text
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "// ==== Registers\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo  = 1'b1;\n"
-       "  assign baar = 1'b0;\n"
-       "  // ==== Registers\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// No space after // also works
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "//============\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo  = 1'b1;\n"
-       "  assign baar = 1'b0;\n"
-       "  //============\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// Slash separator (/////) also works
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "//////////\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo  = 1'b1;\n"
-       "  assign baar = 1'b0;\n"
-       "  //////////\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// Regular comment does NOT break alignment
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "// Title text\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo    = 1'b1;\n"
-       "  assign baar   = 1'b0;\n"
-       "  // Title text\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// Multi-line comment block with separators
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "// ============\n"
-       "// Title\n"
-       "// ============\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo  = 1'b1;\n"
-       "  assign baar = 1'b0;\n"
-       "  // ============\n"
-       "  // Title\n"
-       "  // ============\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// Short repeated body (3 chars) does NOT break
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "// ---\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo    = 1'b1;\n"
-       "  assign baar   = 1'b0;\n"
-       "  // ---\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// Declarations also respect separator comments
-       "module m;\n"
-       "logic       a;\n"
-       "logic [7:0] b;\n"
-       "// ============\n"
-       "logic c_long_name;\n"
-       "logic d;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  logic       a;\n"
-       "  logic [7:0] b;\n"
-       "  // ============\n"
-       "  logic c_long_name;\n"
-       "  logic d;\n"
-       "endmodule\n"},
-      {// Statements in always blocks
-       "module m;\n"
-       "always_comb begin\n"
-       "aaaaa = b;\n"
-       "c     = 1'b0;\n"
-       "// ============\n"
-       "dd = eee;\n"
-       "ffffff = g;\n"
-       "end\n"
-       "endmodule\n",
-       "module m;\n"
-       "  always_comb begin\n"
-       "    aaaaa = b;\n"
-       "    c     = 1'b0;\n"
-       "    // ============\n"
-       "    dd     = eee;\n"
-       "    ffffff = g;\n"
-       "  end\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.alignment_group_boundary = AlignmentGroupBoundary::kSeparatorComments;
-  style.assignment_statement_alignment = AlignmentPolicy::kAlign;
-  style.module_net_variable_alignment = AlignmentPolicy::kAlign;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, AlignmentGroupBoundaryBlankLines) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// Blank line breaks alignment group
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo  = 1'b1;\n"
-       "  assign baar = 1'b0;\n"
-       "\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// No blank line: single alignment group
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo    = 1'b1;\n"
-       "  assign baar   = 1'b0;\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// Single item before blank line (not enough for alignment)
-       "module m;\n"
-       "assign foo = 1'b1;\n"
-       "\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo = 1'b1;\n"
-       "\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-      {// Separator comment does NOT break (only blank lines)
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "// ============\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo    = 1'b1;\n"
-       "  assign baar   = 1'b0;\n"
-       "  // ============\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.alignment_group_boundary = AlignmentGroupBoundary::kBlankLines;
-  style.assignment_statement_alignment = AlignmentPolicy::kAlign;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest,
-     AlignmentGroupBoundaryBlankLinesAndSeparatorComments) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// Both blank line and separator break groups
-       "module m;\n"
-       "assign foo  = 1'b1;\n"
-       "assign baar = 1'b0;\n"
-       "\n"
-       "assign baaaaz = 1'b1;\n"
-       "assign c      = 1'b0;\n"
-       "// ============\n"
-       "assign dd  = 1'b1;\n"
-       "assign eee = 1'b0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  assign foo  = 1'b1;\n"
-       "  assign baar = 1'b0;\n"
-       "\n"
-       "  assign baaaaz = 1'b1;\n"
-       "  assign c      = 1'b0;\n"
-       "  // ============\n"
-       "  assign dd  = 1'b1;\n"
-       "  assign eee = 1'b0;\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.alignment_group_boundary =
-      AlignmentGroupBoundary::kBlankLinesAndSeparatorComments;
-  style.assignment_statement_alignment = AlignmentPolicy::kAlign;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Regression for https://github.com/chipsalliance/verible/issues/2540:
-// Trailing EOL comment after `end` before `else if` must not change whether
-// the else-if assignment stays on one line across re-format (convergence).
-TEST(FormatterEndToEndTest, EndElseIfWithEOLCommentConverges) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// Comment on its own line between end and else if
-       "module m;\n"
-       "  always_comb begin\n"
-       "    case (state)\n"
-       "      STATE_A: begin\n"
-       "        if (cond_aaaa) next_state_value = STATE_B;\n"
-       "        else if (cond_bbbb) begin\n"
-       "          next_state_value = STATE_B;\n"
-       "        end\n"
-       "        // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
-       "        else if (cond_cccc) next_state_value = STATE_C;\n"
-       "      end\n"
-       "    endcase\n"
-       "  end\n"
-       "endmodule\n",
-       "module m;\n"
-       "  always_comb begin\n"
-       "    case (state)\n"
-       "      STATE_A: begin\n"
-       "        if (cond_aaaa) next_state_value = STATE_B;\n"
-       "        else if (cond_bbbb) begin\n"
-       "          next_state_value = STATE_B;\n"
-       "        end  // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
-       "        else if (cond_cccc) next_state_value = STATE_C;\n"
-       "      end\n"
-       "    endcase\n"
-       "  end\n"
-       "endmodule\n"},
-      {// Same construct with comment already on the end line
-       "module m;\n"
-       "  always_comb begin\n"
-       "    case (state)\n"
-       "      STATE_A: begin\n"
-       "        if (cond_aaaa) next_state_value = STATE_B;\n"
-       "        else if (cond_bbbb) begin\n"
-       "          next_state_value = STATE_B;\n"
-       "        end  // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
-       "        else if (cond_cccc) next_state_value = STATE_C;\n"
-       "      end\n"
-       "    endcase\n"
-       "  end\n"
-       "endmodule\n",
-       "module m;\n"
-       "  always_comb begin\n"
-       "    case (state)\n"
-       "      STATE_A: begin\n"
-       "        if (cond_aaaa) next_state_value = STATE_B;\n"
-       "        else if (cond_bbbb) begin\n"
-       "          next_state_value = STATE_B;\n"
-       "        end  // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
-       "        else if (cond_cccc) next_state_value = STATE_C;\n"
-       "      end\n"
-       "    endcase\n"
-       "  end\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;  // default column_limit (100)
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify kAlign behavior for body-level param/localparam declarations
-// in module and package bodies.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBasics) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// localparam alignment in module body
-       "module m;\n"
-       "localparam foo = 4'b0000;\n"
-       "localparam barr = 4'b0010;\n"
-       "localparam baaaaz = 4'b0111;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo    = 4'b0000;\n"
-       "  localparam barr   = 4'b0010;\n"
-       "  localparam baaaaz = 4'b0111;\n"
-       "endmodule\n"},
-      {// localparam alignment in package body
-       "package p;\n"
-       "localparam foo = 4'b0000;\n"
-       "localparam barr = 4'b0010;\n"
-       "localparam baaaaz = 4'b0111;\n"
-       "endpackage\n",
-       "package p;\n"
-       "  localparam foo    = 4'b0000;\n"
-       "  localparam barr   = 4'b0010;\n"
-       "  localparam baaaaz = 4'b0111;\n"
-       "endpackage\n"},
-      {// parameter alignment in module body
-       "module m;\n"
-       "parameter int foo = 1;\n"
-       "parameter int barr = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter int foo  = 1;\n"
-       "  parameter int barr = 2;\n"
-       "endmodule\n"},
-      {// parameter alignment in package body
-       "package p;\n"
-       "parameter int foo = 1;\n"
-       "parameter int barrrr = 2;\n"
-       "endpackage\n",
-       "package p;\n"
-       "  parameter int foo    = 1;\n"
-       "  parameter int barrrr = 2;\n"
-       "endpackage\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify kFlushLeft behavior: body-level param/localparam declarations
-// are not aligned.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentFlushLeft) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// module body: parameters are not aligned
-       "module m;\n"
-       "localparam foo = 4'b0000;\n"
-       "localparam barr = 4'b0010;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo = 4'b0000;\n"
-       "  localparam barr = 4'b0010;\n"
-       "endmodule\n"},
-      {// package context: flush-left
-       "package p;\n"
-       "localparam foo = 4'b0000;\n"
-       "localparam barr = 4'b0010;\n"
-       "endpackage\n",
-       "package p;\n"
-       "  localparam foo = 4'b0000;\n"
-       "  localparam barr = 4'b0010;\n"
-       "endpackage\n"},
-      {// generate context: flush-left
-       "module m;\n"
-       "generate\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "endgenerate\n"
-       "endmodule\n",
-       "module m;\n"
-       "  generate\n"
-       "    localparam foo = 1;\n"
-       "    localparam barr = 2;\n"
-       "  endgenerate\n"
-       "endmodule\n"},
-      {// parameter in module body: flush-left
-       "module m;\n"
-       "parameter int W = 8;\n"
-       "parameter int HHHH = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter int W = 8;\n"
-       "  parameter int HHHH = 2;\n"
-       "endmodule\n"},
-      {// mixed parameter and localparam: flush-left, no alignment
-       "module m;\n"
-       "parameter int W = 8;\n"
-       "localparam L = 4;\n"
-       "parameter int H = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter int W = 8;\n"
-       "  localparam L = 4;\n"
-       "  parameter int H = 2;\n"
-       "endmodule\n"},
-      {// interface context: flush-left
-       "interface my_if;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "endinterface\n",
-       "interface my_if;\n"
-       "  localparam foo = 1;\n"
-       "  localparam barr = 2;\n"
-       "endinterface\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify kPreserve behavior: body-level param/localparam declarations
-// maintain their existing spacing.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPreserve) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// module body: existing spacing is kept
-       "module m;\n"
-       "localparam foo = 4'b0000;\n"
-       "localparam barr  = 4'b0010;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo = 4'b0000;\n"
-       "  localparam barr  = 4'b0010;\n"
-       "endmodule\n"},
-      {// package: existing flush-left spacing preserved
-       "package p;\n"
-       "localparam foo = 4'b0000;\n"
-       "localparam barr = 4'b0010;\n"
-       "endpackage\n",
-       "package p;\n"
-       "  localparam foo = 4'b0000;\n"
-       "  localparam barr = 4'b0010;\n"
-       "endpackage\n"},
-      {// generate: existing aligned spacing preserved
-       "module m;\n"
-       "generate\n"
-       "localparam foo  = 1;\n"
-       "localparam barr = 2;\n"
-       "endgenerate\n"
-       "endmodule\n",
-       "module m;\n"
-       "  generate\n"
-       "    localparam foo  = 1;\n"
-       "    localparam barr = 2;\n"
-       "  endgenerate\n"
-       "endmodule\n"},
-      {// parameter flush-left preserved
-       "module m;\n"
-       "parameter int W = 8;\n"
-       "parameter int HHHH = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter int W = 8;\n"
-       "  parameter int HHHH = 2;\n"
-       "endmodule\n"},
-      {// parameter pre-aligned preserved
-       "module m;\n"
-       "parameter int W    = 8;\n"
-       "parameter int HHHH = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter int W    = 8;\n"
-       "  parameter int HHHH = 2;\n"
-       "endmodule\n"},
-      {// interface pre-aligned preserved
-       "interface my_if;\n"
-       "localparam foo  = 1;\n"
-       "localparam barr = 2;\n"
-       "endinterface\n",
-       "interface my_if;\n"
-       "  localparam foo  = 1;\n"
-       "  localparam barr = 2;\n"
-       "endinterface\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kPreserve;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify kAlign behavior for param/localparam declarations across
-// interface, generate, and module body contexts, including mixed
-// param/localparam and packed dimension alignment.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentContexts) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// interface body localparam alignment
-       "interface my_if;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "endinterface\n",
-       "interface my_if;\n"
-       "  localparam foo  = 1;\n"
-       "  localparam barr = 2;\n"
-       "endinterface\n"},
-      {// interface body parameter alignment
-       "interface my_if;\n"
-       "parameter int X = 1;\n"
-       "parameter int Y_LONG = 2;\n"
-       "endinterface\n",
-       "interface my_if;\n"
-       "  parameter int X      = 1;\n"
-       "  parameter int Y_LONG = 2;\n"
-       "endinterface\n"},
-      {// generate block localparam alignment
-       "module m;\n"
-       "generate\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "endgenerate\n"
-       "endmodule\n",
-       "module m;\n"
-       "  generate\n"
-       "    localparam foo  = 1;\n"
-       "    localparam barr = 2;\n"
-       "  endgenerate\n"
-       "endmodule\n"},
-      {// generate block parameter alignment
-       "module m;\n"
-       "generate\n"
-       "parameter int A = 1;\n"
-       "parameter int BB = 2;\n"
-       "endgenerate\n"
-       "endmodule\n",
-       "module m;\n"
-       "  generate\n"
-       "    parameter int A  = 1;\n"
-       "    parameter int BB = 2;\n"
-       "  endgenerate\n"
-       "endmodule\n"},
-      {// mixed param and net declarations form separate alignment groups
-       "module m;\n"
-       "localparam X = 1;\n"
-       "localparam YYY = 2;\n"
-       "logic clk;\n"
-       "logic rst_n;\n"
-       "localparam ZZ = 3;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam X   = 1;\n"
-       "  localparam YYY = 2;\n"
-       "  logic clk;\n"
-       "  logic rst_n;\n"
-       "  localparam ZZ = 3;\n"
-       "endmodule\n"},
-      {// mixed parameter and localparam in same block
-       "module m;\n"
-       "parameter int W = 8;\n"
-       "localparam L = 4;\n"
-       "parameter int H = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter  int W = 8;\n"
-       "  localparam     L = 4;\n"
-       "  parameter  int H = 2;\n"
-       "endmodule\n"},
-      {// packed dimensions are aligned
-       "module m;\n"
-       "parameter bit [7:0] X = 0;\n"
-       "parameter bit [31:0] YYYY = 1;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter bit [ 7:0] X    = 0;\n"
-       "  parameter bit [31:0] YYYY = 1;\n"
-       "endmodule\n"},
-      {// multi-identifier comma-separated params are not split (no-crash)
-       "module m;\n"
-       "parameter int a=1, b=2, ccc=3;\n"
-       "localparam d=4, e=5;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter  int a = 1, b = 2, ccc = 3;\n"
-       "  localparam     d = 4, e = 5;\n"
-       "endmodule\n"},
-      {// parameter type declarations do not crash
-       "module m;\n"
-       "parameter type T = int;\n"
-       "parameter type TT_LONG = bit;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter type T = int;\n"
-       "  parameter type TT_LONG = bit;\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify kInferUserIntent behavior: body-level param/localparam
-// declarations infer alignment intent from existing spacing.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentInferUserIntent) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// flush-left localparams with small spacing diff: infer aligns
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo  = 1;\n"
-       "  localparam barr = 2;\n"
-       "endmodule\n"},
-      {// pre-aligned localparams: infer preserves alignment
-       "module m;\n"
-       "localparam foo    = 1;\n"
-       "localparam barr   = 2;\n"
-       "localparam baaaaz = 3;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo    = 1;\n"
-       "  localparam barr   = 2;\n"
-       "  localparam baaaaz = 3;\n"
-       "endmodule\n"},
-      {// flush-left params in package with small spacing diff: infer aligns
-       "package p;\n"
-       "localparam X = 1;\n"
-       "localparam YY = 2;\n"
-       "endpackage\n",
-       "package p;\n"
-       "  localparam X  = 1;\n"
-       "  localparam YY = 2;\n"
-       "endpackage\n"},
-      {// mixed param/localparam flush-left: infer keeps flush-left
-       "module m;\n"
-       "parameter int W = 8;\n"
-       "localparam L = 4;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter int W = 8;\n"
-       "  localparam L = 4;\n"
-       "endmodule\n"},
-      {// interface flush-left with small diff: infer aligns
-       "interface my_if;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "endinterface\n",
-       "interface my_if;\n"
-       "  localparam foo  = 1;\n"
-       "  localparam barr = 2;\n"
-       "endinterface\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify boundary behavior for param declarations with
-// kBlankLinesAndSeparatorComments: both blank lines and separator comments
-// break alignment groups.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundary) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// separator comment breaks param alignment group
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "// ============\n"
-       "localparam baaaaz = 1;\n"
-       "localparam c = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo  = 1;\n"
-       "  localparam barr = 2;\n"
-       "  // ============\n"
-       "  localparam baaaaz = 1;\n"
-       "  localparam c      = 2;\n"
-       "endmodule\n"},
-      {// blank line breaks param alignment group
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "\n"
-       "localparam baaaaz = 1;\n"
-       "localparam c = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo  = 1;\n"
-       "  localparam barr = 2;\n"
-       "\n"
-       "  localparam baaaaz = 1;\n"
-       "  localparam c      = 2;\n"
-       "endmodule\n"},
-      {// no separator: single alignment group (all aligned together)
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "localparam baaaaz = 1;\n"
-       "localparam c = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo    = 1;\n"
-       "  localparam barr   = 2;\n"
-       "  localparam baaaaz = 1;\n"
-       "  localparam c      = 2;\n"
-       "endmodule\n"},
-      {// regular comment does NOT break alignment group
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "// regular comment\n"
-       "localparam barr = 2;\n"
-       "localparam baaaaz = 1;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo    = 1;\n"
-       "  // regular comment\n"
-       "  localparam barr   = 2;\n"
-       "  localparam baaaaz = 1;\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  style.alignment_group_boundary =
-      AlignmentGroupBoundary::kBlankLinesAndSeparatorComments;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify edge cases: unpacked dimensions, signed/unsigned, implicit types,
-// complex types, single declarations, deeply nested generate blocks.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentEdgeCases) {
-  // Use column_limit = 80 to avoid unintended line wrapping inside
-  // deeply nested generate blocks (generate-if, generate-for), which
-  // would interfere with verifying alignment behavior.
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// unpacked dimension alignment
-       "module m;\n"
-       "parameter bit X [7:0] = 0;\n"
-       "parameter bit YYYY [15:0] = 1;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter bit X   [ 7:0] = 0;\n"
-       "  parameter bit YYYY[15:0] = 1;\n"
-       "endmodule\n"},
-      {// param declarations with only type and default value (no idim)
-       "module m;\n"
-       "parameter int X = 0;\n"
-       "parameter int YYYY = 0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter int X    = 0;\n"
-       "  parameter int YYYY = 0;\n"
-       "endmodule\n"},
-      {// signed modifier with packed dimensions
-       "module m;\n"
-       "parameter bit signed [7:0] X = 0;\n"
-       "parameter bit signed [31:0] YYYY = 1;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter bit signed [ 7:0] X    = 0;\n"
-       "  parameter bit signed [31:0] YYYY = 1;\n"
-       "endmodule\n"},
-      {// param with complex type (struct/typedef) — does not crash
-       "module m;\n"
-       "parameter foo_t X = foo_t'(0);\n"
-       "parameter foo_t Y_LONG = foo_t'(0);\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter foo_t X      = foo_t'(0);\n"
-       "  parameter foo_t Y_LONG = foo_t'(0);\n"
-       "endmodule\n"},
-      {// single param declaration (not enough for alignment group)
-       "module m;\n"
-       "localparam X = 1;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam X = 1;\n"
-       "endmodule\n"},
-      {// params inside generate-if block
-       "module m;\n"
-       "generate\n"
-       "if (1) begin : blk\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "end\n"
-       "endgenerate\n"
-       "endmodule\n",
-       "module m;\n"
-       "  generate\n"
-       "    if (1) begin : blk\n"
-       "      localparam foo  = 1;\n"
-       "      localparam barr = 2;\n"
-       "    end\n"
-       "  endgenerate\n"
-       "endmodule\n"},
-      {// unsigned keyword with packed dimensions (complement to signed)
-       "module m;\n"
-       "parameter bit unsigned [7:0] X = 0;\n"
-       "parameter bit unsigned [31:0] YYYY = 1;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter bit unsigned [ 7:0] X    = 0;\n"
-       "  parameter bit unsigned [31:0] YYYY = 1;\n"
-       "endmodule\n"},
-      {// parameter with implicit type (no explicit type keyword)
-       "module m;\n"
-       "parameter X = 32;\n"
-       "parameter Y_LONG = 64;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter X      = 32;\n"
-       "  parameter Y_LONG = 64;\n"
-       "endmodule\n"},
-      {// params inside generate-for block
-       "module m;\n"
-       "generate\n"
-       "for (i = 0; i < 2; i++) begin : blk\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "end\n"
-       "endgenerate\n"
-       "endmodule\n",
-       "module m;\n"
-       "  generate\n"
-       "    for (i = 0; i < 2; i++) begin : blk\n"
-       "      localparam foo  = 1;\n"
-       "      localparam barr = 2;\n"
-       "    end\n"
-       "  endgenerate\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 80;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify parameter declarations inside generate-case blocks are aligned.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentGenerateCase) {
-  // Params inside generate-case need wider column limit to avoid wrapping the
-  // case label / begin block line.
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// params inside generate-case block
-       "module m #(P = 0);\n"
-       "generate\n"
-       "case (P)\n"
-       "0: begin : blk\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "end\n"
-       "endcase\n"
-       "endgenerate\n"
-       "endmodule\n",
-       "module m #(\n"
-       "    P = 0\n"
-       ");\n"
-       "  generate\n"
-       "    case (P)\n"
-       "      0: begin : blk\n"
-       "        localparam foo  = 1;\n"
-       "        localparam barr = 2;\n"
-       "      end\n"
-       "    endcase\n"
-       "  endgenerate\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 80;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, FormalAndBodyParamAlignmentIndependence) {
-  // Verify that --formal_parameters_alignment and
-  // --parameter_declaration_alignment act independently: setting formal params
-  // to kFlushLeft should not affect body-level param alignment, and vice versa.
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// formal flush-left + body align: only body params align
-       "module m #(\n"
-       "int W = 2,\n"
-       "int LLLL = 4\n"
-       ");\n"
-       "localparam foo = 0;\n"
-       "localparam barrrr = 0;\n"
-       "endmodule\n",
-       "module m #(\n"
-       "    int W = 2,\n"
-       "    int LLLL = 4\n"
-       ");\n"
-       "  localparam foo    = 0;\n"
-       "  localparam barrrr = 0;\n"
-       "endmodule\n"},
-      {// formal align + body flush-left: only formal params align
-       "module m #(\n"
-       "int W = 2,\n"
-       "int LLLL = 4\n"
-       ");\n"
-       "localparam foo = 0;\n"
-       "localparam barrrr = 0;\n"
-       "endmodule\n",
-       "module m #(\n"
-       "    int W    = 2,\n"
-       "    int LLLL = 4\n"
-       ");\n"
-       "  localparam foo = 0;\n"
-       "  localparam barrrr = 0;\n"
-       "endmodule\n"},
-      {// both flush-left: no alignment anywhere
-       "module m #(\n"
-       "int W = 2,\n"
-       "int LLLL = 4\n"
-       ");\n"
-       "localparam foo = 0;\n"
-       "localparam barrrr = 0;\n"
-       "endmodule\n",
-       "module m #(\n"
-       "    int W = 2,\n"
-       "    int LLLL = 4\n"
-       ");\n"
-       "  localparam foo = 0;\n"
-       "  localparam barrrr = 0;\n"
-       "endmodule\n"},
-      {// both align: both formal and body params aligned
-       "module m #(\n"
-       "int W = 2,\n"
-       "int LLLL = 4\n"
-       ");\n"
-       "localparam foo = 0;\n"
-       "localparam barrrr = 0;\n"
-       "endmodule\n",
-       "module m #(\n"
-       "    int W    = 2,\n"
-       "    int LLLL = 4\n"
-       ");\n"
-       "  localparam foo    = 0;\n"
-       "  localparam barrrr = 0;\n"
-       "endmodule\n"},
-  };
-  // First case: formal kFlushLeft, body kAlign
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-    style.formal_parameters_alignment = AlignmentPolicy::kFlushLeft;
-    const auto &tc = kTestCases[0];
-    VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-  // Second case: formal kAlign, body kFlushLeft
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft;
-    style.formal_parameters_alignment = AlignmentPolicy::kAlign;
-    const auto &tc = kTestCases[1];
-    VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-  // Third case: both kFlushLeft
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft;
-    style.formal_parameters_alignment = AlignmentPolicy::kFlushLeft;
-    const auto &tc = kTestCases[2];
-    VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-  // Fourth case: both kAlign
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-    style.formal_parameters_alignment = AlignmentPolicy::kAlign;
-    const auto &tc = kTestCases[3];
-    VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, ClassBodyParamNotAffected) {
-  // Verify that class body parameter/localparam declarations are NOT affected
-  // by --parameter_declaration_alignment, which targets only module/generate/
-  // package/interface body-level params.
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// class body params are not affected
-       "class c;\n"
-       "parameter int X = 1;\n"
-       "parameter int YYYY = 2;\n"
-       "localparam foo = 3;\n"
-       "localparam barrrr = 4;\n"
-       "endclass\n",
-       "class c;\n"
-       "  parameter int X = 1;\n"
-       "  parameter int YYYY = 2;\n"
-       "  localparam foo = 3;\n"
-       "  localparam barrrr = 4;\n"
-       "endclass\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, PackageBodyVariableAlignment) {
-  // Verify that moving kPackageItemList to kTabularAlignment in tree-unwrapper
-  // enables net/variable declaration alignment in package bodies via
-  // module_net_variable_alignment.
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// net/variable declaration alignment in package body
-       "package p;\n"
-       "logic [7:0] a;\n"
-       "logic [31:0] bb;\n"
-       "endpackage\n",
-       "package p;\n"
-       "  logic [ 7:0] a;\n"
-       "  logic [31:0] bb;\n"
-       "endpackage\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.module_net_variable_alignment = AlignmentPolicy::kAlign;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentApplyToAll) {
-  // Verify that ApplyToAllAlignmentPolicies affects
-  // parameter_declaration_alignment for all four alignment policies.
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// kAlign aligns identifiers and = signs across declarations
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barrrr = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo    = 1;\n"
-       "  localparam barrrr = 2;\n"
-       "endmodule\n"},
-      {// kFlushLeft: declarations remain flush-left
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barrrr = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo = 1;\n"
-       "  localparam barrrr = 2;\n"
-       "endmodule\n"},
-      {// kPreserve: existing spacing is kept
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barrrr  = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo = 1;\n"
-       "  localparam barrrr  = 2;\n"
-       "endmodule\n"},
-      {// kInferUserIntent: large identifier width difference (3 cols)
-       // suggests flush-left intent, no alignment.
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barrrr = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo = 1;\n"
-       "  localparam barrrr = 2;\n"
-       "endmodule\n"},
-  };
-  // kAlign
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kAlign);
-    const auto &tc = kTestCases[0];
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-  // kFlushLeft
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kFlushLeft);
-    const auto &tc = kTestCases[1];
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-  // kPreserve
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kPreserve);
-    const auto &tc = kTestCases[2];
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-  // kInferUserIntent
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kInferUserIntent);
-    const auto &tc = kTestCases[3];
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-}
-
-// Verify that alignment_group_boundary=kBlankLines treats only blank lines
-// (not separator comments) as boundary breaks for param declarations.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundaryBlankLines) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// Only blank line breaks group; separator comment does not
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "\n"
-       "localparam baaaaz = 1;\n"
-       "localparam c = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo  = 1;\n"
-       "  localparam barr = 2;\n"
-       "\n"
-       "  localparam baaaaz = 1;\n"
-       "  localparam c      = 2;\n"
-       "endmodule\n"},
-      {// Separator comment does NOT break group with kBlankLines
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "// ============\n"
-       "localparam baaaaz = 1;\n"
-       "localparam c = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo    = 1;\n"
-       "  localparam barr   = 2;\n"
-       "  // ============\n"
-       "  localparam baaaaz = 1;\n"
-       "  localparam c      = 2;\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  style.alignment_group_boundary = AlignmentGroupBoundary::kBlankLines;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify that alignment_group_boundary=kNone keeps all param declarations
-// in a single alignment group regardless of blank lines or comments.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundaryNone) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// Blank line does NOT break group with kNone
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "\n"
-       "localparam baaaaz = 1;\n"
-       "localparam c = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo    = 1;\n"
-       "  localparam barr   = 2;\n"
-       "\n"
-       "  localparam baaaaz = 1;\n"
-       "  localparam c      = 2;\n"
-       "endmodule\n"},
-      {// Separator comment does NOT break group with kNone
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "// ============\n"
-       "localparam baaaaz = 1;\n"
-       "localparam c = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo    = 1;\n"
-       "  localparam barr   = 2;\n"
-       "  // ============\n"
-       "  localparam baaaaz = 1;\n"
-       "  localparam c      = 2;\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  style.alignment_group_boundary = AlignmentGroupBoundary::kNone;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify that alignment_group_boundary=kSeparatorComments treats only
-// separator comments (not blank lines) as boundary breaks for param
-// declarations.
-TEST(FormatterEndToEndTest,
-     ParamDeclarationAlignmentBoundarySeparatorComments) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// Separator comment breaks alignment group
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "// ============\n"
-       "localparam baaaaz = 1;\n"
-       "localparam c = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo  = 1;\n"
-       "  localparam barr = 2;\n"
-       "  // ============\n"
-       "  localparam baaaaz = 1;\n"
-       "  localparam c      = 2;\n"
-       "endmodule\n"},
-      {// Blank line does NOT break group with kSeparatorComments
-       "module m;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "\n"
-       "localparam baaaaz = 1;\n"
-       "localparam c = 2;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  localparam foo    = 1;\n"
-       "  localparam barr   = 2;\n"
-       "\n"
-       "  localparam baaaaz = 1;\n"
-       "  localparam c      = 2;\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  style.alignment_group_boundary = AlignmentGroupBoundary::kSeparatorComments;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify that class body parameter/localparam declarations are NOT affected
-// by --parameter_declaration_alignment for the kFlushLeft, kPreserve,
-// and kInferUserIntent policies (kAlign is covered in
-// ClassBodyParamNotAffected).
-TEST(FormatterEndToEndTest, ClassBodyParamNotAffectedOtherPolicies) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// kFlushLeft: class body params remain flush-left
-       "class c;\n"
-       "parameter int X = 1;\n"
-       "parameter int YYYY = 2;\n"
-       "localparam foo = 3;\n"
-       "localparam barrrr = 4;\n"
-       "endclass\n",
-       "class c;\n"
-       "  parameter int X = 1;\n"
-       "  parameter int YYYY = 2;\n"
-       "  localparam foo = 3;\n"
-       "  localparam barrrr = 4;\n"
-       "endclass\n"},
-      {// kPreserve: parameter_declaration_alignment does not apply to class
-       // bodies; whitespace is normalized by default formatting.
-       "class c;\n"
-       "parameter int X     = 1;\n"
-       "parameter int YYYY  = 2;\n"
-       "endclass\n",
-       "class c;\n"
-       "  parameter int X = 1;\n"
-       "  parameter int YYYY = 2;\n"
-       "endclass\n"},
-      {// kInferUserIntent: class body params infer flush-left
-       "class c;\n"
-       "parameter int X = 1;\n"
-       "parameter int YYYY = 2;\n"
-       "endclass\n",
-       "class c;\n"
-       "  parameter int X = 1;\n"
-       "  parameter int YYYY = 2;\n"
-       "endclass\n"},
-  };
-  // kFlushLeft
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft;
-    const auto &tc = kTestCases[0];
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-  // kPreserve
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.parameter_declaration_alignment = AlignmentPolicy::kPreserve;
-    const auto &tc = kTestCases[1];
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-  // kInferUserIntent
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent;
-    const auto &tc = kTestCases[2];
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-}
-
-// Verify formal_parameters_alignment and parameter_declaration_alignment
-// independence for kPreserve and kInferUserIntent combinations.
-TEST(FormatterEndToEndTest,
-     FormalAndBodyParamAlignmentIndependenceOtherPolicies) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// formal kPreserve + body kAlign: only body params aligned
-       "module m #(\n"
-       "int W = 2,\n"
-       "int LLLL = 4\n"
-       ");\n"
-       "localparam foo = 0;\n"
-       "localparam barrrr = 0;\n"
-       "endmodule\n",
-       "module m #(\n"
-       "    int W = 2,\n"
-       "    int LLLL = 4\n"
-       ");\n"
-       "  localparam foo    = 0;\n"
-       "  localparam barrrr = 0;\n"
-       "endmodule\n"},
-      {// formal kAlign + body kPreserve: only formal params aligned
-       "module m #(\n"
-       "int W = 2,\n"
-       "int LLLL = 4\n"
-       ");\n"
-       "localparam foo   = 0;\n"
-       "localparam barrrr = 0;\n"
-       "endmodule\n",
-       "module m #(\n"
-       "    int W    = 2,\n"
-       "    int LLLL = 4\n"
-       ");\n"
-       "  localparam foo   = 0;\n"
-       "  localparam barrrr = 0;\n"
-       "endmodule\n"},
-      {// formal kInferUserIntent + body kAlign: only body params aligned
-       "module m #(\n"
-       "int W = 2,\n"
-       "int LLLL = 4\n"
-       ");\n"
-       "localparam foo = 0;\n"
-       "localparam barrrr = 0;\n"
-       "endmodule\n",
-       "module m #(\n"
-       "    int W = 2,\n"
-       "    int LLLL = 4\n"
-       ");\n"
-       "  localparam foo    = 0;\n"
-       "  localparam barrrr = 0;\n"
-       "endmodule\n"},
-  };
-  // formal kPreserve + body kAlign
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-    style.formal_parameters_alignment = AlignmentPolicy::kPreserve;
-    const auto &tc = kTestCases[0];
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-  // formal kAlign + body kPreserve
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.parameter_declaration_alignment = AlignmentPolicy::kPreserve;
-    style.formal_parameters_alignment = AlignmentPolicy::kAlign;
-    const auto &tc = kTestCases[1];
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-  // formal kInferUserIntent + body kAlign
-  {
-    FormatStyle style;
-    style.column_limit = 40;
-    style.indentation_spaces = 2;
-    style.wrap_spaces = 4;
-    style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-    style.formal_parameters_alignment = AlignmentPolicy::kInferUserIntent;
-    const auto &tc = kTestCases[2];
-    std::ostringstream stream;
-    const auto status = FormatVerilog(tc.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input;
-  }
-}
-
-// Verify parameter declarations with string, real, and function-call default
-// value types to exercise the ColumnSchemaScanner on non-standard type tokens.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentTypeVariants) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// parameter real type
-       "module m;\n"
-       "parameter real X = 1.0;\n"
-       "parameter real Y_LONG = 2.0;\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter real X      = 1.0;\n"
-       "  parameter real Y_LONG = 2.0;\n"
-       "endmodule\n"},
-      {// parameter string type
-       "module m;\n"
-       "parameter string s = \"hello\";\n"
-       "parameter string long_s = \"world\";\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter string s      = \"hello\";\n"
-       "  parameter string long_s = \"world\";\n"
-       "endmodule\n"},
-      {// parameter with function call in default value
-       "module m;\n"
-       "parameter int W = func(1, 2);\n"
-       "parameter int H_LONG = other(3);\n"
-       "endmodule\n",
-       "module m;\n"
-       "  parameter int W      = func(1, 2);\n"
-       "  parameter int H_LONG = other(3);\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify parameter_declaration_alignment kInferUserIntent in package bodies.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPackageInfer) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// flush-left params with small diff: infer aligns
-       "package p;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "endpackage\n",
-       "package p;\n"
-       "  localparam foo  = 1;\n"
-       "  localparam barr = 2;\n"
-       "endpackage\n"},
-      {// pre-aligned params: infer preserves
-       "package p;\n"
-       "localparam foo    = 1;\n"
-       "localparam barr   = 2;\n"
-       "localparam baaaaz = 3;\n"
-       "endpackage\n",
-       "package p;\n"
-       "  localparam foo    = 1;\n"
-       "  localparam barr   = 2;\n"
-       "  localparam baaaaz = 3;\n"
-       "endpackage\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify parameter_declaration_alignment boundary behavior in package bodies.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPackageBoundary) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// blank line breaks alignment group in package
-       "package p;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "\n"
-       "localparam baaaaz = 1;\n"
-       "localparam c = 2;\n"
-       "endpackage\n",
-       "package p;\n"
-       "  localparam foo  = 1;\n"
-       "  localparam barr = 2;\n"
-       "\n"
-       "  localparam baaaaz = 1;\n"
-       "  localparam c      = 2;\n"
-       "endpackage\n"},
-      {// separator comment breaks alignment group in package
-       "package p;\n"
-       "localparam foo = 1;\n"
-       "localparam barr = 2;\n"
-       "// ============\n"
-       "localparam baaaaz = 1;\n"
-       "localparam c = 2;\n"
-       "endpackage\n",
-       "package p;\n"
-       "  localparam foo  = 1;\n"
-       "  localparam barr = 2;\n"
-       "  // ============\n"
-       "  localparam baaaaz = 1;\n"
-       "  localparam c      = 2;\n"
-       "endpackage\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  style.alignment_group_boundary =
-      AlignmentGroupBoundary::kBlankLinesAndSeparatorComments;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify the most common default scenario: both formal_parameters_alignment
-// and parameter_declaration_alignment set to kInferUserIntent.
-TEST(FormatterEndToEndTest, BothParamAlignmentsInferUserIntent) {
-  static constexpr FormatterTestCase kTestCases[] = {
-      {// both flush-left with small diff: infer aligns both formal and body
-       "module m #(\n"
-       "int W = 2,\n"
-       "int LL = 4\n"
-       ");\n"
-       "localparam foo = 0;\n"
-       "localparam barr = 0;\n"
-       "endmodule\n",
-       "module m #(\n"
-       "    int W  = 2,\n"
-       "    int LL = 4\n"
-       ");\n"
-       "  localparam foo  = 0;\n"
-       "  localparam barr = 0;\n"
-       "endmodule\n"},
-      {// both infer: pre-aligned formal, pre-aligned body preserved
-       "module m #(\n"
-       "int W    = 2,\n"
-       "int LLLL = 4\n"
-       ");\n"
-       "localparam foo    = 0;\n"
-       "localparam barrrr = 0;\n"
-       "endmodule\n",
-       "module m #(\n"
-       "    int W    = 2,\n"
-       "    int LLLL = 4\n"
-       ");\n"
-       "  localparam foo    = 0;\n"
-       "  localparam barrrr = 0;\n"
-       "endmodule\n"},
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent;
-  style.formal_parameters_alignment = AlignmentPolicy::kInferUserIntent;
-  for (const auto &test_case : kTestCases) {
-    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
-    std::ostringstream stream;
-    const auto status =
-        FormatVerilog(test_case.input, "<filename>", style, stream);
-    EXPECT_OK(status) << status.message();
-    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
-  }
-}
-
-// Verify that a large multi-line comment block between parameter
-// declarations does not crash the formatter.  The tree-unwrapper may
-// produce a partition structure where the comment tokens are absorbed
-// into the following parameter partition, which the alignment code
-// must handle gracefully by skipping alignment for that row.
-TEST(FormatterEndToEndTest, ParamDeclarationAlignmentCommentBlockNoCrash) {
-  // These inputs contain large multi-line comment blocks between
-  // parameter/localparam declarations.  The formatter must not crash
-  // (SIGABRT).  Output correctness is secondary; the formatter may
-  // fall back to preserving the original input when the partition
-  // structure prevents safe alignment.
-  const char *kInputs[] = {
-      "module m;\n"
-      "parameter int W = 8;\n"
-      "// Multi-line comment block\n"
-      "// that spans across\n"
-      "//\n"
-      "// several lines\n"
-      "// of explanatory text\n"
-      "//\n"
-      "// It contains enough\n"
-      "// lines to trigger\n"
-      "// the partition structure\n"
-      "// edge case where\n"
-      "// comment tokens are\n"
-      "// absorbed into the\n"
-      "// following parameter\n"
-      "// partition.\n"
-      "//\n"
-      "localparam int H = 2;\n"
-      "endmodule\n",
-      "package p;\n"
-      "parameter int X = 1;\n"
-      "// Long comment block\n"
-      "// with many lines\n"
-      "//\n"
-      "// of text\n"
-      "//\n"
-      "localparam int Y = 2;\n"
-      "endpackage\n",
-  };
-  FormatStyle style;
-  style.column_limit = 40;
-  style.indentation_spaces = 2;
-  style.wrap_spaces = 4;
-  style.parameter_declaration_alignment = AlignmentPolicy::kAlign;
-  for (const char *input : kInputs) {
-    VLOG(1) << "code-to-format:\n" << input << "<EOF>";
-    std::ostringstream stream;
-    const auto status = FormatVerilog(input, "<filename>", style, stream);
-    // The primary requirement is that the formatter does not crash
-    // (SIGABRT).  Gtest will report failure if the process aborts.
-    // The partition structure may cause output format differences;
-    // the important thing is the formatter handled it gracefully.
-  }
+TEST(FormatterEndToEndTest, SmokeFormatterTestCases) {
+  RunFormatterTestCases40(kSmokeFormatterTestCases);
 }
 
 // Regression for https://github.com/chipsalliance/verible/issues/2352:
diff --git a/verible/verilog/formatting/formatter_wrap_style_test.cc b/verible/verilog/formatting/formatter_wrap_style_test.cc
new file mode 100644
index 0000000..b61fe42
--- /dev/null
+++ b/verible/verilog/formatting/formatter_wrap_style_test.cc
@@ -0,0 +1,3405 @@
+// Copyright 2017-2026 The Verible Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Test cases in this file should be *insensitive* to wrapping penalties.
+// Penalty-sensitive tests belong in formatter-tuning_test.cc.
+
+#include <cctype>
+#include <cstddef>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_split.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "verible/common/formatting/align.h"
+#include "verible/common/formatting/basic-format-style.h"
+#include "verible/common/strings/display-utils.h"
+#include "verible/common/strings/position.h"
+#include "verible/common/util/interval.h"
+#include "verible/common/util/logging.h"
+#include "verible/verilog/formatting/format-style.h"
+#include "verible/verilog/formatting/formatter-test-utils.h"
+#include "verible/verilog/formatting/formatter.h"
+
+namespace verilog {
+namespace formatter {
+namespace {
+
+using absl::StatusCode;
+using testing::HasSubstr;
+using verible::AlignmentPolicy;
+using verible::IndentationStyle;
+using verible::LineNumberSet;
+
+// Empty LineNumberSet means format all lines.
+static const LineNumberSet kEnableAllLines;
+
+// Small case set for diagnostic/control-path tests that previously iterated
+// the monolithic kFormatterTestCases table.
+static constexpr FormatterTestCase kDiagnosticFormatterTestCases[] = {
+    {"", ""},
+    {"\n", "\n"},
+    {"module m;wire w;endmodule\n",
+     "module m;\n"
+     "  wire w;\n"
+     "endmodule\n"},
+    {"class  cc ;\n"
+     "endclass:cc\n",
+     "class cc;\n"
+     "endclass : cc\n"},
+};
+
+TEST(FormatterEndToEndTest, AutoInferAlignment) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {"", ""},
+      {"\n", "\n"},
+      {"class  cc ;\n"
+       "endclass:cc\n",
+       "class cc;\n"
+       "endclass : cc\n"},
+
+      // module port declarations
+      {"module pd(\n"
+       "input wire foo,\n"
+       "output reg bar\n"
+       ");\n"
+       "endmodule:pd\n",
+       "module pd (\n"
+       "    input  wire foo,\n"  // flush-left vs. align are similar enough,
+       "    output reg  bar\n"   // so automatic policy will align.
+       ");\n"
+       "endmodule : pd\n"},
+      {"module pd(\n"
+       "input  foo_pkg::baz_t foo,\n"
+       "output reg  bar\n"
+       ");\n"
+       "endmodule:pd\n",
+       "module pd (\n"
+       "    input foo_pkg::baz_t foo,\n"  // alignment would add too many spaces
+       "    output reg bar\n"             // so infer intent to flush-left.
+       ");\n"
+       "endmodule : pd\n"},
+      {"module pd(\n"
+       "input  foo_pkg::baz_t foo,\n"
+       "output     reg  bar\n"  // user injects 4 excess spaces here ...
+       ");\n"
+       "endmodule:pd\n",
+       "module pd (\n"
+       "    input  foo_pkg::baz_t foo,\n"
+       "    output reg            bar\n"  // ... and triggers alignment.
+       ");\n"
+       "endmodule : pd\n"},
+      {"module pd(\n"
+       "`ifdef FAA\n"  // inside preprocessing conditional
+       "input  baaaz_t foo,\n"
+       "output reg      bar\n"  // user injects 4 excess spaces here ...
+       "`endif\n"
+       ");\n"
+       "endmodule:pd\n",
+       "module pd (\n"
+       "`ifdef FAA\n"
+       "    input  baaaz_t foo,\n"
+       "    output reg     bar\n"  // ... and triggers alignment.
+       "`endif\n"
+       ");\n"
+       "endmodule : pd\n"},
+      {"module pd(\n"
+       "`ifdef FAA\n"  // inside preprocessing conditional
+       "input  baaaz_t foo,\n"
+       "`else\n"
+       "output reg      bar\n"  // user injects 4 excess spaces here ...
+       "`endif\n"
+       ");\n"
+       "endmodule:pd\n",
+       "module pd (\n"
+       "`ifdef FAA\n"
+       "    input  baaaz_t foo,\n"  // aligned
+       "`else\n"                    // aligned across preprocessing directives
+       "    output reg     bar\n"   // ... and triggers alignment.
+       "`endif\n"
+       ");\n"
+       "endmodule : pd\n"},
+      {"module pd(\n"
+       "input logic [31:0] bus,\n"
+       "input logic [7:0] bus2,\n"
+       "`ifdef FAA\n"  // inside preprocessing conditional
+       "input  baaaz_t foo,\n"
+       "`else\n"
+       "output reg      bar,\n"  // user injects 4 excess spaces here ...
+       "`endif\n"
+       "output out_t zout1,\n"
+       "output out_t zout2\n"
+       ");\n"
+       "endmodule:pd\n",
+       "module pd (\n"
+       "    input  logic   [31:0] bus,\n"  // treated as one large group
+       "    input  logic   [ 7:0] bus2,\n"
+       "`ifdef FAA\n"
+       "    input  baaaz_t        foo,\n"  // aligned
+       "`else\n"  // aligned across preprocessing directives
+       "    output reg            bar,\n"  // ... and triggers alignment.
+       "`endif\n"
+       "    output out_t          zout1,\n"
+       "    output out_t          zout2\n"
+       ");\n"
+       "endmodule : pd\n"},
+      {"module pd(\n"
+       "input logic [7:0] bus2,\n"
+       "`ifndef FAA\n"  // inside preprocessing conditional
+       "input logic [31:0] bus,\n"
+       "input  baaaz_t foo,\n"
+       "`elsif BLA\n"
+       "output reg      bar,\n"  // user injects 4 excess spaces here ...
+       "output out_t zout1,\n"
+       "`endif\n"
+       "output out_t zout2\n"
+       ");\n"
+       "endmodule:pd\n",
+       "module pd (\n"
+       "    input  logic   [ 7:0] bus2,\n"
+       "`ifndef FAA\n"
+       "    input  logic   [31:0] bus,\n"  // treated as one large group
+       "    input  baaaz_t        foo,\n"  // aligned
+       "`elsif BLA\n"  // aligned across preprocessing directives
+       "    output reg            bar,\n"  // ... and triggers alignment.
+       "    output out_t          zout1,\n"
+       "`endif\n"
+       "    output out_t          zout2\n"
+       ");\n"
+       "endmodule : pd\n"},
+      {// data declaration and net declaration in ports
+       "module m(\n"
+       "logic [x:y]a    ,\n"    // packed dimensions, induce alignment
+       "wire [pp:qq] [e:f]b\n"  // packed dimensions, 2D
+       ") ;\n"
+       "endmodule\n",
+       "module m (\n"
+       "    logic [  x:y]      a,\n"
+       "    wire  [pp:qq][e:f] b\n"
+       ");\n"
+       "endmodule\n"},
+      {// used-defined data declarations in ports
+       "module m(\n"
+       "a::bb [x:y]a    ,\n"       // packed dimensions, induce alignment
+       "c#(d,e) [pp:qq] [e:f]b\n"  // packed dimensions, 2D
+       ") ;\n"
+       "endmodule\n",
+       "module m (\n"
+       "    a::bb    [  x:y]      a,\n"
+       "    c#(d, e) [pp:qq][e:f] b\n"
+       ");\n"
+       "endmodule\n"},
+
+      // named parameter arguments
+      {"module  mm ;\n"
+       "foo #(\n"
+       ".a(a),\n"
+       ".bb(bb)\n"
+       ")bar( );\n"
+       "endmodule:mm\n",
+       "module mm;\n"
+       "  foo #(\n"
+       "      .a (a),\n"  // align doesn't add too many spaces, so align
+       "      .bb(bb)\n"
+       "  ) bar ();\n"
+       "endmodule : mm\n"},
+      {"module  mm ;\n"
+       "foo #(\n"
+       ".a(a),\n"
+       ".bbcccc(bb)\n"
+       ")bar( );\n"
+       "endmodule:mm\n",
+       "module mm;\n"
+       "  foo #(\n"
+       "      .a(a),\n"  // align would add too many spaces, so flush-left
+       "      .bbcccc(bb)\n"
+       "  ) bar ();\n"
+       "endmodule : mm\n"},
+      {"module  mm ;\n"
+       "foo #(\n"
+       ".a(a    ),\n"  // user manually triggers alignment with excess spaces
+       ".bbcccc(bb)\n"
+       ")bar( );\n"
+       "endmodule:mm\n",
+       "module mm;\n"
+       "  foo #(\n"
+       "      .a     (a),\n"  // induced alignment
+       "      .bbcccc(bb)\n"
+       "  ) bar ();\n"
+       "endmodule : mm\n"},
+      {"module  mm ;\n"
+       "foo #(\n"
+       "//c1\n"        // with comments (indented but not aligned)
+       ".a(a    ),\n"  // user manually triggers alignment with excess spaces
+       "//c2\n"
+       ".bbcccc(bb)\n"
+       "//c3\n"
+       ")bar( );\n"
+       "endmodule:mm\n",
+       "module mm;\n"
+       "  foo #(\n"
+       "      //c1\n"
+       "      .a     (a),\n"  // induced alignment
+       "      //c2\n"
+       "      .bbcccc(bb)\n"
+       "      //c3\n"
+       "  ) bar ();\n"
+       "endmodule : mm\n"},
+      {"module  mm ;\n"
+       "foo #(\n"
+       ".a( (1     +2)),\n"  // excess spaces, testing extra parentheses
+       ".bbcccc((c*d)+(e*f))\n"
+       ")bar( );\n"
+       "endmodule:mm\n",
+       "module mm;\n"
+       "  foo #(\n"
+       "      .a     ((1 + 2)),\n"  // induced alignment
+       "      .bbcccc((c * d) + (e * f))\n"
+       "  ) bar ();\n"
+       "endmodule : mm\n"},
+
+      // named port connections
+      {"module  mm ;\n"
+       "foo bar(\n"
+       ".a(a),\n"
+       ".bb(bb)\n"
+       ");\n"
+       "endmodule:mm\n",
+       "module mm;\n"
+       "  foo bar (\n"
+       "      .a (a),\n"  // align doesn't add too many spaces, so align
+       "      .bb(bb)\n"
+       "  );\n"
+       "endmodule : mm\n"},
+      {"module  mm ;\n"
+       "foo bar(\n"
+       ".a(a),\n"
+       ".bbbbbb(bb)\n"
+       ");\n"
+       "endmodule:mm\n",
+       "module mm;\n"
+       "  foo bar (\n"
+       "      .a(a),\n"  // align would add too many spaces, so flush-left
+       "      .bbbbbb(bb)\n"
+       "  );\n"
+       "endmodule : mm\n"},
+      {"module  mm ;\n"
+       "foo bar(\n"
+       ".a    (a),\n"  // user manually triggers alignment with excess spaces
+       ".bbbbbb(bb)\n"
+       ");\n"
+       "endmodule:mm\n",
+       "module mm;\n"
+       "  foo bar (\n"
+       "      .a     (a),\n"  // alignment fixed
+       "      .bbbbbb(bb)\n"
+       "  );\n"
+       "endmodule : mm\n"},
+
+      // net variable declarations
+      {"module nn;\n"
+       "wire wwwww;\n"
+       "logic lll;\n"
+       "endmodule : nn\n",
+       "module nn;\n"
+       "  wire  wwwww;\n"  // alignment adds few spaces, so align
+       "  logic lll;\n"
+       "endmodule : nn\n"},
+      {"module nn;\n"
+       "wire wwwww;\n"
+       "foo_pkg::baz_t lll;\n"
+       "endmodule : nn\n",
+       "module nn;\n"
+       "  wire wwwww;\n"  // alignment adds too many spaces, so flush-left
+       "  foo_pkg::baz_t lll;\n"
+       "endmodule : nn\n"},
+      {"module nn;\n"
+       "wire     wwwww;\n"  // user injects spaces to trigger alignment
+       "foo_pkg::baz_t lll;\n"
+       "endmodule : nn\n",
+       "module nn;\n"
+       "  wire           wwwww;\n"  // ... and gets alignment
+       "  foo_pkg::baz_t lll;\n"
+       "endmodule : nn\n"},
+      {// data/net declarations as generate items (conditional)
+       "module nn;\n"
+       "if (cc)begin:fff\n"
+       "wire wwwww;\n"
+       "logic lll;\n"
+       "end:fff\n"
+       "endmodule : nn\n",
+       "module nn;\n"
+       "  if (cc) begin : fff\n"
+       "    wire  wwwww;\n"  // alignment adds few spaces, so align
+       "    logic lll;\n"
+       "  end : fff\n"
+       "endmodule : nn\n"},
+
+      // continuous assignments
+      {"module m_assign;\n"
+       "assign foo = 1'b1;\n"  // alignment adds few spaces, so align
+       "assign baar = 1'b0;\n"
+       "endmodule\n",
+       "module m_assign;\n"
+       "  assign foo  = 1'b1;\n"  // aligned
+       "  assign baar = 1'b0;\n"
+       "endmodule\n"},
+      {"module m_assign;\n"
+       "assign foo  =  1'b1;\n"  // alignment adds too many spaces, so
+                                 // flush-left
+       "assign baaaaaar = 1'b0;\n"
+       "endmodule\n",
+       "module m_assign;\n"
+       "  assign foo = 1'b1;\n"  // flush-left
+       "  assign baaaaaar = 1'b0;\n"
+       "endmodule\n"},
+      {"module m_assign;\n"
+       "assign foo  =     1'b1;\n"  // induce alignment with excess spaces
+       "assign baaaaaar = 1'b0;\n"
+       "endmodule\n",
+       "module m_assign;\n"
+       "  assign foo      = 1'b1;\n"  // aligned
+       "  assign baaaaaar = 1'b0;\n"
+       "endmodule\n"},
+      {// currently, does not assign across ifdefs
+       "module m_assign;\n"
+       "`ifdef FOO\n"
+       "assign foo  =     1'b1;\n"  // induce alignment with excess spaces
+       "assign baaaaaar = 1'b0;\n"
+       "`else\n"
+       "assign zooo = 2'b11;\n"
+       "assign yoo = 2'b00;\n"
+       "`endif\n"
+       "endmodule\n",
+       "module m_assign;\n"
+       "`ifdef FOO\n"
+       "  assign foo      = 1'b1;\n"  // aligned
+       "  assign baaaaaar = 1'b0;\n"
+       "`else\n"                   // aligned separately above/below
+       "  assign zooo = 2'b11;\n"  // aligned
+       "  assign yoo  = 2'b00;\n"  // aligned
+       "`endif\n"
+       "endmodule\n"},
+      {// mixed net declaration and continuous assignment, both groups aligned
+       "module m_assign;\n"
+       "wire     wwwww;\n"  // induce alignment
+       "foo_pkg::baz_t lll;\n"
+       "assign foo  =     1'b1;\n"  // induce alignment
+       "assign baaaaaar = 1'b0;\n"
+       "endmodule\n",
+       "module m_assign;\n"
+       "  wire           wwwww;\n"  // aligned
+       "  foo_pkg::baz_t lll;\n"
+       "  assign foo      = 1'b1;\n"  // aligned
+       "  assign baaaaaar = 1'b0;\n"
+       "endmodule\n"},
+      {// continuous assignments as generate items (conditional)
+       "module m_assign;\n"
+       "if (xy) begin\n"
+       "assign foo  =  1'b0;\n"  // align: adds few spaces
+       "assign baaar = 1'b1;\n"
+       "end else begin\n"
+       "assign goo  =      1'b1;\n"  // induce alignment with excess spaces
+       "assign zaaaaaar = 1'b0;\n"
+       "end\n"
+       "endmodule\n",
+       "module m_assign;\n"
+       "  if (xy) begin\n"
+       "    assign foo   = 1'b0;\n"  // aligned
+       "    assign baaar = 1'b1;\n"
+       "  end else begin\n"
+       "    assign goo      = 1'b1;\n"  // induce alignment with excess spaces
+       "    assign zaaaaaar = 1'b0;\n"
+       "  end\n"
+       "endmodule\n"},
+      {// continuous assignments as generate items (loop)
+       "module m_assign;\n"
+       "for(genvar i=0; i<k; ++i ) begin\n"
+       "assign foo  =  1'b0;\n"  // align: adds few spaces
+       "assign baaar = 1'b1;\n"
+       "end\n"
+       "endmodule\n",
+       "module m_assign;\n"
+       "  for (genvar i = 0; i < k; ++i) begin\n"
+       "    assign foo   = 1'b0;\n"  // aligned
+       "    assign baaar = 1'b1;\n"
+       "  end\n"
+       "endmodule\n"},
+      {// continuous assignments as generate items (case)
+       "module m_assign;\n"
+       "case (c)\n"
+       "jk:begin\n"
+       "assign foo  =  1'b0;\n"  // align: adds few spaces
+       "assign baaar = 1'b1;\n"
+       "end\n"
+       "endcase\n"
+       "endmodule\n",
+       "module m_assign;\n"
+       "  case (c)\n"
+       "    jk: begin\n"
+       "      assign foo   = 1'b0;\n"  // aligned
+       "      assign baaar = 1'b1;\n"
+       "    end\n"
+       "  endcase\n"
+       "endmodule\n"},
+      {// continuous assignment with comment
+       "module m;\n"
+       "// comment1\n"
+       "assign aaaaa = (bbbbb != ccccc) &\n"
+       "// comment2\n"
+       "(ddddd | (eeeee & ffffff));\n"
+       "endmodule\n",
+       "module m;\n"
+       "  // comment1\n"
+       "  assign aaaaa = (bbbbb != ccccc) &\n"
+       "      // comment2\n"
+       "      (ddddd | (eeeee & ffffff));\n"
+       "endmodule\n"},
+
+      // net/variable assignments: blocking and nonblocking
+      {"module  ma ;\n"
+       "initial  begin\n"
+       "aa = b;\n"
+       "c = 1'b0;\n"
+       "end\n"
+       "endmodule\n",
+       "module ma;\n"
+       "  initial begin\n"
+       "    aa = b;\n"
+       "    c  = 1'b0;\n"  // only one space to align
+       "  end\n"
+       "endmodule\n"},
+      {"function void  fa ;\n"
+       "c = 1'b0;\n"
+       "aa = b;\n"
+       "endfunction\n",
+       "function void fa;\n"
+       "  c  = 1'b0;\n"  // only one space to align
+       "  aa = b;\n"
+       "endfunction\n"},
+      {"task  ta ; \n"
+       "aa =  b;\n"
+       "c = 1'b0;\n"
+       "endtask\n",
+       "task ta;\n"
+       "  aa = b;\n"
+       "  c  = 1'b0;\n"  // only one space to align
+       "endtask\n"},
+      {"module  ma ;\n"
+       "always@( posedge clk) begin\n"
+       "aaa <= b;\n"
+       "c <= 1'b0;\n"
+       "end\n"
+       "endmodule\n",
+       "module ma;\n"
+       "  always @(posedge clk) begin\n"
+       "    aaa <= b;\n"
+       "    c   <= 1'b0;\n"  // only two spaces to align
+       "  end\n"
+       "endmodule\n"},
+      {"function int  fa ;\n"
+       "c <= 1'b0;\n"
+       "aa <= b;\n"
+       "return 0 ;\n"
+       "endfunction\n",
+       "function int fa;\n"
+       "  c  <= 1'b0;\n"  // only one space to align
+       "  aa <= b;\n"
+       "  return 0;\n"
+       "endfunction\n"},
+      {"task  ta ; \n"
+       "$display (\"hello\" );\n"
+       "aa <=  b;\n"
+       "c <= 1'b0;\n"
+       "endtask\n",
+       "task ta;\n"
+       "  $display(\"hello\");\n"
+       "  aa <= b;\n"
+       "  c  <= 1'b0;\n"  // only one space to align
+       "endtask\n"},
+      {// mixed blocking and nonblocking assignments
+       "module  ma ;\n"
+       "always@( posedge clk) begin\n"
+       "aaaaa  = b;\n"
+       "ccc  = 1'b0;\n"
+       "aaa <= b;\n"
+       "c <= 1'b0;\n"
+       "end\n"
+       "endmodule\n",
+       "module ma;\n"
+       "  always @(posedge clk) begin\n"
+       "    aaaaa = b;\n"
+       "    ccc   = 1'b0;\n"  // only two spaces to align
+       "    aaa <= b;\n"
+       "    c   <= 1'b0;\n"  // only two spaces to align (separate group)
+       "  end\n"
+       "endmodule\n"},
+      {"task  ta ; \n"
+       "aa <=  b;\n"
+       "c <= 1'b0;\n"
+       "$display (\"hello\" );\n"  // separates above/below alignment groups
+       "zzaa <=  b;\n"
+       "zzc <= 1'b0;\n"
+       "endtask\n",
+       "task ta;\n"
+       "  aa <= b;\n"
+       "  c  <= 1'b0;\n"  // only one space to align
+       "  $display(\"hello\");\n"
+       "  zzaa <= b;\n"
+       "  zzc  <= 1'b0;\n"  // only one space to align
+       "endtask\n"},
+      {"task  ta ; \n"
+       "$display (\"hello\" );\n"
+       "aaaaa <=  b;\n"
+       "c <= 1'b0;\n"  // need too many spaces to align
+       "endtask\n",
+       "task ta;\n"
+       "  $display(\"hello\");\n"
+       "  aaaaa <= b;\n"
+       "  c <= 1'b0;\n"  // so keep flush-left
+       "endtask\n"},
+      {"function void  fa ; \n"
+       "$display (\"hello\" );\n"
+       "aaaaa =  b;\n"
+       "c = 1'b0;\n"  // need too many spaces to align
+       "endfunction\n",
+       "function void fa;\n"
+       "  $display(\"hello\");\n"
+       "  aaaaa = b;\n"
+       "  c = 1'b0;\n"  // so keep flush-left
+       "endfunction\n"},
+      {"module  ma ;\n"
+       "always@( posedge clk) begin\n"
+       "aaaxx <= b;\n"
+       "c <= 1'b0;\n"  // need too many spaces to align
+       "end\n"
+       "endmodule\n",
+       "module ma;\n"
+       "  always @(posedge clk) begin\n"
+       "    aaaxx <= b;\n"
+       "    c <= 1'b0;\n"  // so keep flush-left
+       "  end\n"
+       "endmodule\n"},
+      {"module  ma ;\n"
+       "always@( posedge clk) begin\n"
+       "aaaxx <= b    ;\n"  // inject 4 spaces to induce alignment
+       "c <= 1'b0;\n"
+       "end\n"
+       "endmodule\n",
+       "module ma;\n"
+       "  always @(posedge clk) begin\n"
+       "    aaaxx <= b;\n"
+       "    c     <= 1'b0;\n"  // induced alignment
+       "  end\n"
+       "endmodule\n"},
+      {"module  ma ;\n"
+       "always@( posedge clk) begin\n"
+       "aaaxx <= b    ;\n"  // inject 4 spaces to induce alignment
+       "//comment\n"
+       "c <= 1'b0;\n"
+       "end\n"
+       "endmodule\n",
+       "module ma;\n"
+       "  always @(posedge clk) begin\n"
+       "    aaaxx <= b;\n"
+       "    //comment\n"       // ignored within alignment group
+       "    c     <= 1'b0;\n"  // induced alignment
+       "  end\n"
+       "endmodule\n"},
+
+      // local variable declarations as statements
+      {"task tt ;\n"
+       "int foo;\n"  // only 2 spaces needed to align
+       "bar_t baz;\n"
+       "endtask\n",
+       "task tt;\n"
+       "  int   foo;\n"  // aligned
+       "  bar_t baz;\n"
+       "endtask\n"},
+      {"function ff ;\n"
+       "bar_t baz;\n"
+       "int foo;\n"  // only 2 spaces needed to align
+       "endfunction\n",
+       "function ff;\n"
+       "  bar_t baz;\n"
+       "  int   foo;\n"  // aligned
+       "endfunction\n"},
+      {"task tt ;\n"
+       "int  foo;\n"  // too many spaces needed to align
+       "baaaar_t baz;\n"
+       "endtask\n",
+       "task tt;\n"
+       "  int foo;\n"  // so flush-left
+       "  baaaar_t baz;\n"
+       "endtask\n"},
+      {"function ff ;\n"
+       "baaaar_t baz;\n"
+       "int  foo;\n"  // too many spaces needed to align
+       "endfunction\n",
+       "function ff;\n"
+       "  baaaar_t baz;\n"
+       "  int foo;\n"  // so flush-left
+       "endfunction\n"},
+      {"task tt ;\n"
+       "int        foo;\n"  // injected spaces to induce alignment
+       "baaaar_t baz;\n"
+       "endtask\n",
+       "task tt;\n"
+       "  int      foo;\n"  // aligned
+       "  baaaar_t baz;\n"
+       "endtask\n"},
+      {"function ff ;\n"
+       "baaaar_t baz    ;\n"  // injected spaces to induce alignment
+       "int  foo;\n"
+       "endfunction\n",
+       "function ff;\n"
+       "  baaaar_t baz;\n"
+       "  int      foo;\n"  // so aligned
+       "endfunction\n"},
+
+      // formal parameters
+      {"module pp #(\n"
+       "int W,\n"
+       "type T\n"
+       ") ();\n"
+       "endmodule : pp\n",
+       "module pp #(\n"
+       "    int  W,\n"  // alignment adds few spaces, so do it
+       "    type T\n"
+       ") ();\n"
+       "endmodule : pp\n"},
+      {"module pp #(\n"
+       "int W,\n"
+       "int[xx:yy] T\n"
+       ") ();\n"
+       "endmodule : pp\n",
+       "module pp #(\n"
+       "    int W,\n"  // alignment adds many spaces, so flush-left
+       "    int [xx:yy] T\n"
+       ") ();\n"
+       "endmodule : pp\n"},
+      {"module pp #(\n"
+       "int W,\n"
+       "int[xx:yy]     T\n"  // user injected spaces intentionally
+       ") ();\n"
+       "endmodule : pp\n",
+       "module pp #(\n"
+       "    int         W,\n"  // ... trigger alignment
+       "    int [xx:yy] T\n"
+       ") ();\n"
+       "endmodule : pp\n"},
+
+      // class member variables
+      {"class  cc ;\n"
+       "int my_int;\n"
+       "bar_t my_bar;\n"
+       "endclass:cc\n",
+       "class cc;\n"
+       "  int   my_int;\n"  // align doesn't add too many spaces, so align
+       "  bar_t my_bar;\n"
+       "endclass : cc\n"},
+      {"class  cc ;\n"
+       "int   my_int;\n"
+       "foo_pkg::bar_t my_bar;\n"
+       "endclass:cc\n",
+       "class cc;\n"
+       "  int my_int;\n"  // align would add too many spaces, so flush-left
+       "  foo_pkg::bar_t my_bar;\n"
+       "endclass : cc\n"},
+      {"class  cc ;\n"
+       "int     my_int;\n"  // intentional excessive spaces, trigger alignment
+       "foo_pkg::bar_t my_bar;\n"
+       "endclass:cc\n",
+       "class cc;\n"
+       "  int            my_int;\n"
+       "  foo_pkg::bar_t my_bar;\n"
+       "endclass : cc\n"},
+      {"class  cc ;\n"
+       "int    my_int;\n"  // unable to infer user's intent, so preserve
+       "foo_pkg::bar_t  my_bar;\n"
+       "endclass:cc\n",
+       "class cc;\n"
+       "  int    my_int;\n"  // ... but still indent
+       "  foo_pkg::bar_t  my_bar;\n"
+       "endclass : cc\n"},
+
+      // case item test cases
+      {// small difference between flush-left and align, so align
+       "function f; case (x)kZZZZ  :if( b )break; default :return 2;"
+       "endcase endfunction\n",
+       "function f;\n"
+       "  case (x)\n"
+       "    kZZZZ:   if (b) break;\n"  // aligned, only adds 2 spaces
+       "    default: return 2;\n"
+       "  endcase\n"
+       "endfunction\n"},
+      {// small error relative to flush-left, so flush-left
+       "function f; case (x)kZ  :if( b )break; default :return 2;"
+       "endcase endfunction\n",
+       "function f;\n"
+       "  case (x)\n"
+       "    kZ: if (b) break;\n"  // flush-left
+       "    default: return 2;\n"
+       "  endcase\n"
+       "endfunction\n"},
+      {// intentional spacing error (delta=4) induces alignment
+       "function f; case (x)kZ  :if( b )break; default    :return 2;"
+       "endcase endfunction\n",
+       "function f;\n"
+       "  case (x)\n"
+       "    kZ:      if (b) break;\n"
+       "    default: return 2;\n"
+       "  endcase\n"
+       "endfunction\n"},
+      {// induced alignment, with ignored comments
+       "function f; case (x)kZ  :if( b )break; \n//c1\n kXX: g = f; "
+       "\n//c2\ndefault    :return 2;"
+       "endcase endfunction\n",
+       "function f;\n"
+       "  case (x)\n"
+       "    kZ:      if (b) break;\n"
+       "    //c1\n"
+       "    kXX:     g = f;\n"
+       "    //c2\n"
+       "    default: return 2;\n"
+       "  endcase\n"
+       "endfunction\n"},
+      {// induced alignment, ignore multiline case item in the middle
+       "function f; case (x)"
+       "kZ  :if( b )break; "
+       "kYY    :return 2;"          // excess spaces induce alignment
+       "    kXXXXXXXXX: begin end"  // multi-line, ignored
+       "    kWWWWW: cc = 23;\n"
+       "    kVVV: cd = 24;\n"
+       "endcase endfunction\n",
+       "function f;\n"
+       "  case (x)\n"
+       "    kZ:     if (b) break;\n"
+       "    kYY:    return 2;\n"
+       "    kXXXXXXXXX: begin\n"  // separates above/below groups
+       "    end\n"
+       "    kWWWWW: cc = 23;\n"
+       "    kVVV:   cd = 24;\n"  // aligned
+       "  endcase\n"
+       "endfunction\n"},
+      {// induced alignment, ignore multiline case item in the middle
+       "function f; case (x)"
+       "kZ  :if( b )break; "
+       "kYY    :return 2;"               // excess spaces induce alignment
+       "    kXXXXXXXXX: if(w)begin end"  // multi-line, ignored
+       "    kWWWWW: cc = 23;\n"
+       "    kVVV: cd = 24;\n"
+       "endcase endfunction\n",
+       "function f;\n"
+       "  case (x)\n"
+       "    kZ:     if (b) break;\n"
+       "    kYY:    return 2;\n"
+       "    kXXXXXXXXX:\n"   // TODO(fangism): allow this to merge with if()
+                             // else indent the following two lines
+       "    if (w) begin\n"  // separates above/below groups
+       "    end\n"
+       "    kWWWWW: cc = 23;\n"
+       "    kVVV:   cd = 24;\n"  // aligned
+       "  endcase\n"
+       "endfunction\n"},
+      {// induced alignment, ignore multiline case item in the middle
+       "task t; case (x)"
+       "kZ  :if( b )break; "
+       "kYY    :return 2;"           // excess spaces induce alignment
+       "    kXXXXXXXXX: fork  join"  // multi-line, ignored
+       "    kWWWWW: cc = 23;\n"
+       "    kVVV: cd = 24;\n"
+       "endcase endtask\n",
+       "task t;\n"
+       "  case (x)\n"
+       "    kZ:     if (b) break;\n"
+       "    kYY:    return 2;\n"
+       "    kXXXXXXXXX:\n"  // TODO(fangism): allow this to merge with fork
+                            // else indent the following two lines
+       "    fork\n"         // separates above/below groups
+       "    join\n"
+       "    kWWWWW: cc = 23;\n"
+       "    kVVV:   cd = 24;\n"  // aligned
+       "  endcase\n"
+       "endtask\n"},
+      {// case-inside: small difference between flush-left and align, so align
+       "function f; case (x)inside [0:3]  :yy=zzz; [4:11] :yy=zz;"
+       "endcase endfunction\n",
+       "function f;\n"
+       "  case (x) inside\n"
+       "    [0 : 3]:  yy = zzz;\n"  // aligned, only adds 1 spaces
+       "    [4 : 11]: yy = zz;\n"
+       "  endcase\n"
+       "endfunction\n"},
+      {// case-inside: align with comments
+       "function f; case (x)inside \n//c1\n[0:3]  :yy=zzz;\n//c2\n"
+       " [4:11] :yy=zz;\n//c3\n"
+       "endcase endfunction\n",
+       "function f;\n"
+       "  case (x) inside\n"
+       "    //c1\n"
+       "    [0 : 3]:  yy = zzz;\n"  // aligned, only adds 1 spaces
+       "    //c2\n"
+       "    [4 : 11]: yy = zz;\n"
+       "    //c3\n"
+       "  endcase\n"
+       "endfunction\n"},
+      {// case-inside: flush left
+       "function f; case (x)inside [0:3]  :yy=zzz; [4:999999] :yy=zz;"
+       "endcase endfunction\n",
+       "function f;\n"
+       "  case (x) inside\n"
+       "    [0 : 3]: yy = zzz;\n"  // flush-left
+       "    [4 : 999999]: yy = zz;\n"
+       "  endcase\n"
+       "endfunction\n"},
+      {// case-inside: induce alignment
+       "function f; case (x)inside [0:3    ]  :yy=zzz; [4:999999] :yy=zz;"
+       "endcase endfunction\n",
+       "function f;\n"
+       "  case (x) inside\n"
+       "    [0 : 3]:      yy = zzz;\n"  // aligned
+       "    [4 : 999999]: yy = zz;\n"
+       "  endcase\n"
+       "endfunction\n"},
+      {// case-generate: align would add few spaces, so align
+       "module mc ; case (x)kZ  : gg h(); kXYY :j kk();"
+       "endcase endmodule\n",
+       "module mc;\n"
+       "  case (x)\n"
+       "    kZ:   gg h ();\n"  // align
+       "    kXYY: j kk ();\n"
+       "  endcase\n"
+       "endmodule\n"},
+      {// case-generate + comment: align would add few spaces, so align
+       "module mc ; case (x)kZ  : gg h(); \n//c1\n kXYY :j kk();"
+       "endcase endmodule\n",
+       "module mc;\n"
+       "  case (x)\n"
+       "    kZ:   gg h ();\n"  // align
+       "    //c1\n"
+       "    kXYY: j kk ();\n"
+       "  endcase\n"
+       "endmodule\n"},
+      {// case-generate: align would add too many space, so flush-left
+       "module mc ; case (x)kZ  : gg h(); kXYYYY :j kk();"
+       "endcase endmodule\n",
+       "module mc;\n"
+       "  case (x)\n"
+       "    kZ: gg h ();\n"  // flush-left
+       "    kXYYYY: j kk ();\n"
+       "  endcase\n"
+       "endmodule\n"},
+      {// case-generate: inject spaces to induce alignment
+       "module mc ; case (x)kZ  : gg h(); kXYYYY :     j kk();"
+       "endcase endmodule\n",
+       "module mc;\n"
+       "  case (x)\n"
+       "    kZ:     gg h ();\n"  // align
+       "    kXYYYY: j kk ();\n"
+       "  endcase\n"
+       "endmodule\n"},
+      {// randcase: align (small difference from flush-left)
+       "task trc  ;randcase 10: x = 1; 1: x = 3; endcase endtask",
+       "task trc;\n"
+       "  randcase\n"
+       "    10: x = 1;\n"
+       "    1:  x = 3;\n"  // aligned
+       "  endcase\n"
+       "endtask\n"},
+      {// randcase: inferred flush-left
+       "task trc  ;randcase 10000: x = 1; 1: x = 3; endcase endtask",
+       "task trc;\n"
+       "  randcase\n"
+       "    10000: x = 1;\n"
+       "    1: x = 3;\n"
+       "  endcase\n"
+       "endtask\n"},
+      {// randcase: induce alignment
+       "task trc  ;randcase 10000: x = 1    ; 1: x = 3; endcase endtask",
+       "task trc;\n"
+       "  randcase\n"
+       "    10000: x = 1;\n"
+       "    1:     x = 3;\n"  // aligned
+       "  endcase\n"
+       "endtask\n"},
+
+      // distributions
+      {"class foo;\n"
+       "constraint c { "
+       "timer_enable dist {\n"
+       "8'hfe :=  9 , \n"
+       "12'hfff  := 1 }; "
+       "} endclass\n",
+       "class foo;\n"
+       "  constraint c {\n"
+       "    timer_enable dist {\n"
+       "      8'hfe   := 9,\n"  // only two spaces needed to align
+       "      12'hfff := 1\n"   // so align
+       "    };\n"
+       "  }\n"
+       "endclass\n"},
+      {"class foo;\n"
+       "constraint c { "
+       "timer_enable dist {\n"
+       "[ 8'h0 : 8'hfe ] :/  9 , \n"
+       "8'hff  :/ 1 }; "  // takes many spaces to align this, so...
+       "} endclass\n",
+       "class foo;\n"
+       "  constraint c {\n"
+       "    timer_enable dist {\n"
+       "      [8'h0 : 8'hfe] :/ 9,\n"
+       "      8'hff :/ 1\n"  // flush-left
+       "    };\n"
+       "  }\n"
+       "endclass\n"},
+      {"class foo;\n"
+       "constraint c { "
+       "timer_enable dist {\n"
+       "[ 8'h0 : 8'hfe ] :/  9 , \n"
+       "8'hff  :/     1 }; "  // inject excess spaces to trigger alignment
+       "} endclass\n",
+       "class foo;\n"
+       "  constraint c {\n"
+       "    timer_enable dist {\n"
+       "      [8'h0 : 8'hfe] :/ 9,\n"
+       "      8'hff          :/ 1\n"  // aligned
+       "    };\n"
+       "  }\n"
+       "endclass\n"},
+      {"class foo;\n"
+       "constraint c { "
+       "timer_enable dist {\n"
+       "//comment1\n"
+       "[ 8'h0 : 8'hfe ] :/  9 , \n"
+       "//comment2\n"
+       "8'hff  :/     1 \n"
+       "//comment3\n"
+       "}; "  // inject excess spaces to trigger alignment
+       "} endclass\n",
+       "class foo;\n"
+       "  constraint c {\n"
+       "    timer_enable dist {\n"
+       "      //comment1\n"
+       "      [8'h0 : 8'hfe] :/ 9,\n"
+       "      //comment2\n"           // align across comment
+       "      8'hff          :/ 1\n"  // aligned
+       "      //comment3\n"
+       "    };\n"
+       "  }\n"
+       "endclass\n"},
+      {"module foo ();\n"
+       "  always @(posedge bar) begin\n"
+       "    if (1==1) begin\n"
+       "      ham();\n"
+       "    end else if (2==2) begin\n"
+       "      jam();\n"
+       "    end else begin\n"
+       "      spam();\n"
+       "    end\n"
+       "  end\n"
+       "endmodule\n",
+       "module foo ();\n"
+       "  always @(posedge bar) begin\n"
+       "    if (1 == 1) begin\n"
+       "      ham();\n"
+       "    end else if (2 == 2) begin\n"
+       "      jam();\n"
+       "    end else begin\n"
+       "      spam();\n"
+       "    end\n"
+       "  end\n"
+       "endmodule\n"},
+  };
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  // Override some settings to test auto-inferred alignment.
+  style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kInferUserIntent);
+
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}  // NOLINT(readability/fn_size)
+
+static constexpr FormatterTestCase kFormatterWideTestCases[] = {
+    // specify blocks
+    {"module  specify_tests ;\n"
+     "specify\n"  // empty list
+     "endspecify\n"
+     "endmodule",
+     "module specify_tests;\n"
+     "  specify\n"
+     "  endspecify\n"
+     "endmodule\n"},
+    {"module  specify_tests ;\n"
+     "specify\n"
+     "$recrem (posedge R, posedge C,\n"
+     "t1, t2);\n"
+     "endspecify\n"
+     "endmodule",
+     "module specify_tests;\n"
+     "  specify\n"
+     "    $recrem(posedge R, posedge C, t1, t2);\n"
+     "  endspecify\n"
+     "endmodule\n"},
+    {"module  specify_tests ;\n"
+     "specify\n"
+     "// TODO: add this\n"
+     "endspecify \n"
+     "endmodule",
+     "module specify_tests;\n"
+     "  specify\n"
+     "    // TODO: add this\n"
+     "  endspecify\n"
+     "endmodule\n"},
+    {"module  specify_tests ;\n"
+     "specify  \n"
+     "  //c1\n"
+     "$setup (  posedge A, posedge B,\n"
+     "t1);//c2\n"
+     " //c3\n"
+     "$hold (  posedge B , posedge A,t2);    //c4\n"
+     "\t//c5\n"
+     "endspecify\n"
+     "endmodule",
+     "module specify_tests;\n"
+     "  specify\n"
+     "    //c1\n"
+     "    $setup(posedge A, posedge B, t1);  //c2\n"
+     "    //c3\n"
+     "    $hold(posedge B, posedge A, t2);  //c4\n"
+     "    //c5\n"
+     "  endspecify\n"
+     "endmodule\n"},
+    {"module  specify_tests ;\n"
+     "specify  \n"
+     "$setup (  posedge A, posedge B,\n"
+     "t1);\n"
+     "$hold (  posedge B , posedge A,t2);\n"
+     "endspecify\n"
+     "endmodule",
+     "module specify_tests;\n"
+     "  specify\n"
+     "    $setup(posedge A, posedge B, t1);\n"
+     "    $hold(posedge B, posedge A, t2);\n"
+     "  endspecify\n"
+     "endmodule\n"},
+    {"module  specify_tests ;\n"
+     "specify  \n"
+     "  `ifdef CCC\n"
+     "$setup (  posedge A, posedge B,\n"
+     "t1);\n"
+     " `else\n"
+     "$hold (  posedge B , posedge A,t2);   \n"
+     "\t`endif\n"
+     "endspecify\n"
+     "endmodule",
+     "module specify_tests;\n"
+     "  specify\n"
+     "`ifdef CCC\n"
+     "    $setup(posedge A, posedge B, t1);\n"
+     "`else\n"
+     "    $hold(posedge B, posedge A, t2);\n"
+     "`endif\n"
+     "  endspecify\n"
+     "endmodule\n"},
+};
+
+// These tests just need a larger column limit to fit on one line.
+TEST(FormatterEndToEndTest, VerilogFormatWideTest) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 60;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  for (const auto &test_case : kFormatterWideTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, DisableModulePortDeclarations) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {"", ""},
+      {"\n", "\n"},
+      {"\n\n", "\n\n"},
+      {"module  m  ;\t\n"
+       "  endmodule\n",
+       "module m;\n"
+       "endmodule\n"},
+      {"module  m(   ) ;\n"
+       "  endmodule\n",
+       "module m ();\n"  // empty ports formatted compactly
+       "endmodule\n"},
+      {// for a single port, the alignment handler doesn't even consider it a
+       // group so it falls back to standard flush-left behavior.
+       "module  m   ( input     clk  )\t;\n"
+       "  endmodule\n",
+       "module m (\n"
+       "    input clk\n"
+       ");\n"
+       "endmodule\n"},
+      {// example with two ports
+       "module  m   (\n"
+       "input  clk,\n"
+       "output bar\n"
+       ")\t;\n"
+       "  endmodule\n",
+       "module m (\n"
+       "    input  clk,\n"  // indented, but internal pre-existing spacing
+                            // preserved
+       "    output bar\n"
+       ");\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.port_declarations_alignment = verible::AlignmentPolicy::kPreserve;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, DisableModuleInstantiations) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {"", ""},
+      {"\n", "\n"},
+      {"\n\n", "\n\n"},
+      {"module  m  ;\t\n"
+       "  endmodule\n",
+       "module m;\n"
+       "endmodule\n"},
+      {"module  m  ;\t\n"
+       "foo bar();"
+       "  endmodule\n",
+       "module m;\n"
+       "  foo bar ();\n"  // indentation still takes effect
+       "endmodule\n"},
+      {"module  m  ;\t\n"
+       "logic   xyz;"
+       "wire\tabc;"
+       "  endmodule\n",
+       "module m;\n"
+       "  logic xyz;\n"  // indentation still takes effect
+       "  wire  abc;\n"  // aligned too
+       "endmodule\n"},
+      {"  function f  ;\t\n"
+       " endfunction\n",
+       "function f;\n"
+       "endfunction\n"},
+      {"  function f  ;\t"
+       "foo  bar,baz; "
+       " endfunction\n",
+       "function f;\n"
+       "  foo bar, baz;\n"
+       "endfunction\n"},
+      {"  task  t  ;\t"
+       "foo  bar,baz; "
+       " endtask\n",
+       "task t;\n"
+       "  foo bar, baz;\n"
+       "endtask\n"},
+      {"module  m  ;\t\n"
+       "foo  bar(   .baz(baz)   );"
+       "  endmodule\n",
+       "module m;\n"
+       "  foo bar (.baz(baz));\n"  // indentation still takes effect
+       "endmodule\n"},
+      {"module  m  ;\t\n"
+       "foo  bar(\n"
+       "        .baz  (baz  ),\n"  // example of user-manual alignment
+       "        .blaaa(blaaa)\n"
+       ");"
+       "  endmodule\n",
+       "module m;\n"
+       "  foo bar (\n"           // indentation still takes effect
+       "      .baz  (baz  ),\n"  // named port connections preserved
+       "      .blaaa(blaaa)\n"   // named port connections preserved
+       "  );\n"                  // this indentation is fixed
+       "endmodule\n"},
+      {"module  m  ;\t\n"
+       "foo  #(   .baz(baz)   ) bar();"  // named parameters
+       "  endmodule\n",
+       "module m;\n"
+       "  foo #(.baz(baz)) bar ();\n"  // indentation still takes effect
+       "endmodule\n"},
+      {"module  m  ;\t\n"
+       "foo  #(\n"
+       "        .baz  (baz  ),\n"  // example of user-manual alignment
+       "        .blaaa(blaaa)\n"
+       ")  bar( );"
+       "  endmodule\n",
+       "module m;\n"
+       "  foo #(\n"              // indentation still takes effect
+       "      .baz  (baz  ),\n"  // named parameter arguments preserved
+       "      .blaaa(blaaa)\n"   // named parameter arguments preserved
+       "  ) bar ();\n"           // this indentation is fixed
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  // Testing preservation of spaces
+  style.named_parameter_alignment = AlignmentPolicy::kPreserve;
+  style.named_port_alignment = AlignmentPolicy::kPreserve;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, DisableTryWrapLongLines) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {"", ""},
+      {"\n", "\n"},
+      {"\n\n", "\n\n"},
+      {"module  m  ;\t\n"
+       "  endmodule\n",
+       "module m;\n"
+       "endmodule\n"},
+      {"module  m(   ) ;\n"
+       "  endmodule\n",
+       "module m ();\n"
+       "endmodule\n"},
+      {"module  m(   ) ;\n"
+       "initial assign a = b;\n"
+       "  endmodule\n",
+       "module m ();\n"
+       "  initial assign a = b;\n"
+       "endmodule\n"},
+      {"module  m(   ) ;\n"
+       "initial assign a = {never +gonna +give +you +up,\n"
+       "never + gonna +Let +you +down};\n"
+       "  endmodule\n",
+       "module m ();\n"
+       "  initial\n"
+       "    assign a = {\n"
+       "      never + gonna + give + you + up,\n"
+       "      never + gonna + Let + you + down\n"
+       "    };\n"
+       "endmodule\n"},
+      {"module  m(   ) ;\n"
+       "initial assign a = {never +gonna +give +you +up+\n"  // over 40 columns,
+                                                             // give up
+       "never + gonna +Let +you +down};\n"
+       "  endmodule\n",
+       "module m ();\n"
+       "  initial\n"
+       "    assign a = {\n"
+       "      never +gonna +give +you +up+\n"  // indented properly, but
+       "never + gonna +Let +you +down\n"       // preserved original
+       "    };\n"
+       "endmodule\n"},
+      {// The if-header is a single leaf partition, and does not fit,
+       // so its original spacing should be preserved.
+       // We deliberately insert weird spacing to show that it is preserved.
+       "function f;\n"
+       "if ((xxx.aaaa >= bbbbbbbbbbbbbbb) &&\n"
+       "      ((ccc.ddd  +  eee.ffffff * g) <=\n"
+       "       (hhhhhhhhhhhhhhh+iiiiiiiiiiiiiiiiiiii))) begin\n"
+       "end\n"
+       "endfunction\n",
+       "function f;\n"
+       "  if ((xxx.aaaa >= bbbbbbbbbbbbbbb) &&\n"  // indentation fixed
+       "      ((ccc.ddd  +  eee.ffffff * g) <=\n"
+       "       (hhhhhhhhhhhhhhh+iiiiiiiiiiiiiiiiiiii))) begin\n"
+       "  end\n"  // indentation fixed
+       "endfunction\n"},
+
+      // Make sure indentation still works with wrapping disabled,
+      // and leaf partitions fit on one line.
+      {"function void f();\n"
+       "for (int i = N; i > 0; i--) begin\n"
+       "end\n"
+       "endfunction\n",
+       "function void f();\n"
+       "  for (int i = N; i > 0; i--) begin\n"
+       "  end\n"
+       "endfunction\n"},
+      {"function void f();"
+       "if(i > 0 ) begin end "
+       "endfunction",
+       "function void f();\n"
+       "  if (i > 0) begin\n"
+       "  end\n"
+       "endfunction\n"},
+      {"function void f();"  // newlines absent from input
+       "for (int i=N; i>0; i--) begin end "
+       "endfunction",
+       "function void f();\n"
+       "  for (int i = N; i > 0; i--) begin\n"  // spacing corrected
+       "  end\n"
+       "endfunction\n"},
+      {"module m( );\n"
+       "  always_ff  @  (  posedge  (  clk  )  ) begin\n"
+       "out  <=  rst_clk  ?  0 : in  ;\n"
+       "end\n"
+       "endmodule : simple\n",
+       "module m ();\n"
+       "  always_ff @(posedge (clk)) begin\n"
+       "    out <= rst_clk ? 0 : in;\n"
+       "  end\n"
+       "endmodule : simple\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.try_wrap_long_lines = false;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, ModulePortDeclarationsIndentNotWrap) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {"", ""},
+      {"\n", "\n"},
+      {"\n\n", "\n\n"},
+      {"module  m  ;\t\n"
+       "  endmodule\n",
+       "module m;\n"
+       "endmodule\n"},
+      {"module  m(   ) ;\n"
+       "  endmodule\n",
+       "module m ();\n"  // empty ports formatted compactly
+       "endmodule\n"},
+      {// single port example
+       "module  m   ( input     clk  )\t;\n"
+       "  endmodule\n",
+       "module m (\n"
+       "  input clk\n"  // 2 spaces
+       ");\n"
+       "endmodule\n"},
+      {// example with two ports
+       "module  m   (\n"
+       "input  clk,\n"
+       "output bar\n"
+       ")\t;\n"
+       "  endmodule\n",
+       "module m (\n"
+       "  input  clk,\n"  // indented 2 spaces, and aligned
+       "  output bar\n"
+       ");\n"
+       "endmodule\n"},
+      {// interface example
+       "interface  handshake   (\n"
+       "wire req,\n"
+       "wire ack\n"
+       ")\t;\n"
+       "  endinterface\n",
+       "interface handshake (\n"
+       "  wire req,\n"  // indented 2 spaces
+       "  wire ack\n"
+       ");\n"
+       "endinterface\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  // Indent 2 spaces instead of wrapping 4 spaces.
+  style.port_declarations_indentation = IndentationStyle::kIndent;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, NamedPortConnectionsIndentNotWrap) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {"", ""},
+      {"\n", "\n"},
+      {"\n\n", "\n\n"},
+      {"module  m  ;\t\n"
+       "  endmodule\n",
+       "module m;\n"
+       "endmodule\n"},
+      {"module  m(   ) ;\n"
+       "  endmodule\n",
+       "module m ();\n"  // empty ports formatted compactly
+       "endmodule\n"},
+      {// single port example
+       "module  m ;\n"
+       "foo bar( .clk( clk ) )\t;\n"
+       "  endmodule\n",
+       "module m;\n"
+       "  foo bar (.clk(clk));\n"
+       "endmodule\n"},
+      {// two port example
+       "module  m ;\n"
+       "foo bar( .clk2( clk ),.data (data) )\t;\n"
+       "  endmodule\n",
+       "module m;\n"
+       "  foo bar (\n"
+       "    .clk2(clk),\n"  // indent only +2 spaces
+       "    .data(data)\n"
+       "  );\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  // Indent 2 spaces instead of wrapping 4 spaces.
+  style.named_port_indentation = IndentationStyle::kIndent;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, WrapEndElseStatements) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {"module foo ();\n"
+       "  always @(posedge bar) begin\n"
+       "    if (1==1) begin\n"
+       "      ham();\n"
+       "    end else if (2==2) begin\n"
+       "      jam();\n"
+       "    end else begin\n"
+       "      spam();\n"
+       "    end\n"
+       "  end\n"
+       "endmodule\n",
+       "module foo ();\n"
+       "  always @(posedge bar) begin\n"
+       "    if (1 == 1) begin\n"
+       "      ham();\n"
+       "    end\n"
+       "    else if (2 == 2) begin\n"
+       "      jam();\n"
+       "    end\n"
+       "    else begin\n"
+       "      spam();\n"
+       "    end\n"
+       "  end\n"
+       "endmodule\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.wrap_end_else_clauses = true;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, FormalParametersIndentNotWrap) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {"", ""},
+      {"\n", "\n"},
+      {"\n\n", "\n\n"},
+      {"module  m  ;\t\n"
+       "  endmodule\n",
+       "module m;\n"
+       "endmodule\n"},
+      {"module  m #(   ) ;\n"  // empty parameters
+       "  endmodule\n",
+       "module m #();\n"
+       "endmodule\n"},
+      {// single parameter example
+       "module  m   #( int W = 2)\t;\n"
+       "  endmodule\n",
+       "module m #(\n"
+       "  int W = 2\n"  // indented 2 spaces
+       ");\n"
+       "endmodule\n"},
+      {// module with two parameters
+       "module  m   #(\n"
+       "int W = 2,\n"
+       "int L = 4\n"
+       ")\t;\n"
+       "  endmodule\n",
+       "module m #(\n"
+       "  int W = 2,\n"  // indented 2 spaces
+       "  int L = 4\n"
+       ");\n"
+       "endmodule\n"},
+      {// interface with two parameters
+       "interface  m   #(\n"
+       "int W = 2,\n"
+       "int L = 4\n"
+       ")\t;\n"
+       "  endinterface\n",
+       "interface m #(\n"
+       "  int W = 2,\n"  // indented 2 spaces
+       "  int L = 4\n"
+       ");\n"
+       "endinterface\n"},
+      {// class with two parameters
+       "class  c   #(\n"
+       "int W = 2,\n"
+       "int L = 4\n"
+       ")\t;\n"
+       "  endclass\n",
+       "class c #(\n"
+       "  int W = 2,\n"  // indented 2 spaces
+       "  int L = 4\n"
+       ");\n"
+       "endclass\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  // Indent 2 spaces instead of wrapping 4 spaces.
+  style.formal_parameters_indentation = IndentationStyle::kIndent;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, NamedParametersIndentNotWrap) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {"", ""},
+      {"\n", "\n"},
+      {"\n\n", "\n\n"},
+      {"module  m  ;\t\n"
+       "  endmodule\n",
+       "module m;\n"
+       "endmodule\n"},
+      {"module  m #(   ) ;\n"  // empty parameters
+       "  endmodule\n",
+       "module m #();\n"
+       "endmodule\n"},
+      {"module  m  ;\t\n"
+       " foo #()bar();\n"
+       "  endmodule\n",
+       "module m;\n"
+       "  foo #() bar ();\n"
+       "endmodule\n"},
+      {// one named parameter
+       "module  m ;\n"
+       "foo #(.W(1)) bar();\n"
+       "  endmodule\n",
+       "module m;\n"
+       "  foo #(.W(1)) bar ();\n"
+       "endmodule\n"},
+      {// two named parameters
+       "module  m ;\n"
+       "foo #(.W(1), .L(2)) bar();\n"
+       "  endmodule\n",
+       "module m;\n"
+       "  foo #(\n"
+       "    .W(1),\n"  // indent +2 spaces only
+       "    .L(2)\n"
+       "  ) bar ();\n"
+       "endmodule\n"},
+      {// class data member with two parameters
+       "class  c  ;\n"
+       " foo_pkg::bar_t#(\n"
+       ".W(2),.L(4)"
+       ") baz;\n"
+       "  endclass\n",
+       "class c;\n"
+       "  foo_pkg::bar_t #(\n"
+       "    .W(2),\n"  // indent +2 spaces only
+       "    .L(4)\n"
+       "  ) baz;\n"
+       "endclass\n"},
+      {// typedef with two parameters
+       "typedef \n"
+       " foo_pkg::bar_t  #("
+       ".W(2),.L(4)"
+       ") baz;\n",
+       "typedef foo_pkg::bar_t#(\n"
+       "  .W(2),\n"  // indent +2 spaces only
+       "  .L(4)\n"
+       ") baz;\n"},
+  };
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  // Indent 2 spaces instead of wrapping 4 spaces.
+  style.named_parameter_indentation = IndentationStyle::kIndent;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+struct SelectLinesTestCase {
+  std::string_view input;
+  LineNumberSet lines;  // explicit set of lines to enable formatting
+  std::string_view expected;
+};
+
+// Tests that formatter honors selected line numbers.
+TEST(FormatterEndToEndTest, SelectLines) {
+  const SelectLinesTestCase kTestCases[] = {
+      {"", {}, ""},
+      {"", {{1, 2}}, ""},
+      {// expect all three lines for format
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n",
+       {},
+       "parameter int foo_line1 = 0;\n"
+       "parameter int foo_line2 = 0;\n"
+       "parameter int foo_line3 = 0;\n"},
+      {// expect only one line to format
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n",
+       {{1, 2}},
+       "parameter int foo_line1 = 0;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n"},
+      {// expect only one line to format
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n",
+       {{2, 3}},
+       "  parameter    int foo_line1 =     0 ;\n"
+       "parameter int foo_line2 = 0;\n"
+       "  parameter    int foo_line3 =     0 ;\n"},
+      {// expect only one line to format
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n",
+       {{3, 4}},
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "parameter int foo_line3 = 0;\n"},
+      {// expect to format two lines
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n",
+       {{1, 3}},
+       "parameter int foo_line1 = 0;\n"
+       "parameter int foo_line2 = 0;\n"
+       "  parameter    int foo_line3 =     0 ;\n"},
+      {// expect to format two lines
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n",
+       {{2, 4}},
+       "  parameter    int foo_line1 =     0 ;\n"
+       "parameter int foo_line2 = 0;\n"
+       "parameter int foo_line3 = 0;\n"},
+      {// expect to format two lines
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n",
+       {{1, 2}, {3, 4}},
+       "parameter int foo_line1 = 0;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "parameter int foo_line3 = 0;\n"},
+      {// expect to format all lines
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n",
+       {{1, 4}},
+       "parameter int foo_line1 = 0;\n"
+       "parameter int foo_line2 = 0;\n"
+       "parameter int foo_line3 = 0;\n"},
+      {// expect to format no lines (line numbers out of bounds)
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n",
+       {{4, 6}},
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n"},
+      {// expect to format all lines
+       "// verilog_format: on\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n"
+       "  parameter    int foo_line4 =     0 ;\n",
+       {},
+       "// verilog_format: on\n"
+       "parameter int foo_line2 = 0;\n"
+       "parameter int foo_line3 = 0;\n"
+       "parameter int foo_line4 = 0;\n"},
+      {// expect to format no lines
+       "// verilog_format: off\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n"
+       "  parameter    int foo_line4 =     0 ;\n",
+       {},
+       "// verilog_format: off\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n"
+       "  parameter    int foo_line4 =     0 ;\n"},
+      {// expect to format some lines
+       "// verilog_format: on\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n"
+       "  parameter    int foo_line4 =     0 ;\n",
+       {{3, 5}},
+       "// verilog_format: on\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "parameter int foo_line3 = 0;\n"  // disable lines 3,4
+       "parameter int foo_line4 = 0;\n"},
+      {// enable all lines, but respect format-off
+       "  parameter    int foo_line1 =     0 ;\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "// verilog_format: off\n"
+       "  parameter    int foo_line4 =     0 ;\n",
+       {{1, 5}},
+       "parameter int foo_line1 = 0;\n"
+       "parameter int foo_line2 = 0;\n"
+       "// verilog_format: off\n"
+       "  parameter    int foo_line4 =     0 ;\n"},
+      {// enable all lines, but respect format-off
+       "  parameter    int foo_line1 =     0 ;\n"
+       "// verilog_format: off\n"
+       "  parameter    int foo_line3 =     0 ;\n"
+       "// verilog_format: on\n"
+       "  parameter    int foo_line5 =     0 ;\n",
+       {{1, 6}},
+       "parameter int foo_line1 = 0;\n"
+       "// verilog_format: off\n"
+       "  parameter    int foo_line3 =     0 ;\n"
+       "// verilog_format: on\n"
+       "parameter int foo_line5 = 0;\n"},
+      {// enable all lines, but respect format-off
+       "// verilog_format: off\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n"
+       "// verilog_format: on\n"
+       "  parameter    int foo_line5 =     0 ;\n",
+       {{1, 6}},
+       "// verilog_format: off\n"
+       "  parameter    int foo_line2 =     0 ;\n"
+       "  parameter    int foo_line3 =     0 ;\n"
+       "// verilog_format: on\n"
+       "parameter int foo_line5 = 0;\n"},
+      {"module m;\n"
+       "  if (foo) begin:l1\n"
+       "    if (foo) begin:l2\n"
+       "      always_comb\n"  // normally this line and next would fit together
+       "        d<=#1ps   x_lat\t;\n"  // only format this line, 5
+       "    end : l2\n"
+       "  end : l1\n"
+       "endmodule\n",
+       {{5, 6}},
+       "module m;\n"
+       "  if (foo) begin:l1\n"
+       "    if (foo) begin:l2\n"
+       "      always_comb\n"  // incremental mode prevents joining next line
+       "        d <= #1ps x_lat;\n"  // only this line changed
+       "    end : l2\n"
+       "  end : l1\n"
+       "endmodule\n"},
+
+      // Next three test cases: one whole-file, two incremental
+      {"module m(\n"
+       "  input wire f,\n"
+       "  input  foo::bar  ggg\n"
+       ");\n"
+       "endmodule:m\n",
+       {},  // format all lines
+       "module m (\n"
+       "    input wire     f,\n"
+       "    input foo::bar ggg\n"
+       ");\n"
+       "endmodule : m\n"},
+      {"module m(\n"
+       "  input wire f,\n"
+       "  input  foo::bar  ggg\n"  // "new line", formatted incrementally
+       ");\n"
+       "endmodule:m\n",
+       {{3, 4}},  // format incrementally
+       "module m(\n"
+       "  input wire f,\n"
+       "    input  foo::bar  ggg\n"  // "new line" remains untouched
+       ");\n"
+       "endmodule:m\n"},
+      {"module m(\n"
+       "  input  wire   f,\n"  // "new line", formatted incrementally
+       "  input  foo::bar  ggg\n"
+       ");\n"
+       "endmodule:m\n",
+       {{2, 3}},  // format incrementally
+       "module m(\n"
+       "    input  wire   f,\n"  // "new line" indented, but other spaces kept
+       "  input  foo::bar  ggg\n"
+       ");\n"
+       "endmodule:m\n"},
+  };
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status = FormatVerilog(test_case.input, "<filename>", style,
+                                      stream, test_case.lines);
+    EXPECT_OK(status) << status.message() << '\n'
+                      << "Lines: " << test_case.lines;
+    EXPECT_EQ(stream.str(), test_case.expected)
+        << "code:\n"
+        << test_case.input << "\nlines: " << test_case.lines;
+  }
+}
+
+// These tests verify the mode where horizontal spacing is discarded while
+// vertical spacing is preserved.
+TEST(FormatterEndToEndTest, PreserveVSpacesOnly) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      // {input, expected},
+      // No tokens cases: still preserve vertical spacing, but not horizontal
+      {"", ""},
+      {"    ", ""},
+      {"\n", "\n"},
+      {"\n\n", "\n\n"},
+      {"  \n", "\n"},
+      {"\n  ", "\n"},
+      {"  \n  ", "\n"},
+      {"  \n  \t\t\n\t  ", "\n\n"},
+
+      // The remaining cases have at least one non-whitespace token.
+
+      // single comment
+      {"//\n", "//\n"},
+      {"//  \n", "//  \n"},  // trailing spaces inside comment untouched
+      {"\n//\n", "\n//\n"},
+      {"\n\n//\n", "\n\n//\n"},
+      {"\n//\n\n", "\n//\n\n"},
+      {"      //\n", "//\n"},  // spaces before comment discarded
+      {"   \n   //\n", "\n//\n"},
+      {"   \n   //\n  \n  ", "\n//\n\n"},  // trailing spaces discarded
+
+      // multi-comment
+      {"//\n//\n", "//\n//\n"},
+      {"\n//\n\n//\n\n", "\n//\n\n//\n\n"},
+      {"\n//\n\n//\n", "\n//\n\n//\n"},  // blank line between comments
+
+      // Module cases with token partition boundary (before 'endmodule').
+      {"module foo;endmodule\n", "module foo;\nendmodule\n"},
+      {"module foo;\nendmodule\n", "module foo;\nendmodule\n"},
+      {"module foo;\n\nendmodule\n", "module foo;\n\nendmodule\n"},
+      {"\nmodule foo;endmodule\n", "\nmodule foo;\nendmodule\n"},
+      {"\nmodule foo     ;    endmodule\n", "\nmodule foo;\nendmodule\n"},
+      {"\nmodule\nfoo\n;endmodule\n", "\nmodule foo;\nendmodule\n"},
+      {"\nmodule foo;endmodule\n\n\n", "\nmodule foo;\nendmodule\n\n\n"},
+      {"\n\n\nmodule foo;endmodule\n", "\n\n\nmodule foo;\nendmodule\n"},
+      {"\nmodule\nfoo\n;\n\n\nendmodule\n", "\nmodule foo;\n\n\nendmodule\n"},
+
+      // Module cases with one indented item, various original vertical spacing
+      {"module foo;wire w;endmodule\n", "module foo;\n  wire w;\nendmodule\n"},
+      {"  module   foo  ;wire    w  ;endmodule  \n  ",
+       "module foo;\n  wire w;\nendmodule\n"},
+      {"\nmodule\nfoo\n;\nwire\nw\n;endmodule\n\n",
+       "\nmodule foo;\n  wire w;\nendmodule\n\n"},
+      {"\n\nmodule\nfoo\n;\n\n\nwire\nw\n;\n\nendmodule\n\n",
+       "\n\nmodule foo;\n\n\n  wire w;\n\nendmodule\n\n"},
+
+      // The following cases show that some horizontal whitespace is discarded,
+      // while vertical spacing is preserved on partition boundaries.
+      {"     module  foo\t   \t;    endmodule   \n",
+       "module foo;\nendmodule\n"},
+      {"\t\n     module  foo\t\t;    endmodule   \n",
+       "\nmodule foo;\nendmodule\n"},
+
+      // Module with comments intermingled.
+      {
+          "//1\nmodule foo;//2\nwire w;//3\n//4\nendmodule\n",
+          "//1\nmodule foo;  //2\n  wire w;  //3\n  //4\nendmodule\n"
+          // TODO(fangism): whether or not //4 should be indented is
+          // questionable (in similar cases below too).
+      },
+      {// now with extra blank lines
+       "//1\n\nmodule foo;//2\n\nwire w;//3\n\n//4\n\nendmodule\n\n",
+       "//1\n\nmodule foo;  //2\n\n  wire w;  //3\n\n  //4\n\nendmodule\n\n"},
+
+      {
+          // module with comments-only in some empty blocks, properly indented
+          "  // humble module\n"
+          "  module foo (// non-port comment\n"
+          "// port comment 1\n"
+          "// port comment 2\n"
+          ");// header trailing comment\n"
+          "// item comment 1\n"
+          "// item comment 2\n"
+          "endmodule\n",
+          "// humble module\n"
+          "module foo (  // non-port comment\n"
+          "    // port comment 1\n"
+          "    // port comment 2\n"
+          ");  // header trailing comment\n"
+          "  // item comment 1\n"
+          "  // item comment 2\n"
+          "endmodule\n",
+      },
+
+      {
+          // module with comments around non-empty blocks
+          "  // humble module\n"
+          "  module foo (// non-port comment\n"
+          "// port comment 1\n"
+          "input   logic   f  \n"
+          "// port comment 2\n"
+          ");// header trailing comment\n"
+          "// item comment 1\n"
+          "wire w ; \n"
+          "// item comment 2\n"
+          "endmodule\n",
+          "// humble module\n"
+          "module foo (  // non-port comment\n"
+          "    // port comment 1\n"
+          "    input logic f\n"
+          "    // port comment 2\n"
+          ");  // header trailing comment\n"
+          "  // item comment 1\n"
+          "  wire w;\n"
+          "  // item comment 2\n"
+          "endmodule\n",
+      },
+  };
+  FormatStyle style;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+static constexpr FormatterTestCase kFormatterTestCasesElseStatements[] = {
+    {"module m;"
+     "task static t; if (r == t) a.b(c); else d.e(f); endtask;"
+     "endmodule",
+     "module m;\n"
+     "  task static t;\n"
+     "    if (r == t) a.b(c);\n"
+     "    else d.e(f);\n"
+     "  endtask\n"
+     "  ;\n"  // possibly unintended stray ';'
+     "endmodule\n"},
+    {"module m;"
+     "task static t; if (r == t) begin a.b(c); end else begin d.e(f); end "
+     "endtask;"
+     "endmodule",
+     "module m;\n"
+     "  task static t;\n"
+     "    if (r == t) begin\n"
+     "      a.b(c);\n"
+     "    end else begin\n"
+     "      d.e(f);\n"
+     "    end\n"
+     "  endtask\n"
+     "  ;\n"  // stray ';'
+     "endmodule\n"},
+    {"module m;initial begin if(a==b)"
+     "c.d(e);else\n"
+     "f.g(h);end endmodule",
+     "module m;\n"
+     "  initial begin\n"
+     "    if (a == b) c.d(e);\n"
+     "    else f.g(h);\n"
+     "  end\n"
+     "endmodule\n"},
+    {"   module m;  always_comb    begin     \n"
+     "        if      ( a   ) b =  16'hdead    ; \n"
+     "  else if (   c     )  d= 16 'hbeef  ;   \n"
+     "     else        if (e) f=16'hca_fe ;     \n"
+     "end   \n endmodule\n",
+     "module m;\n"
+     "  always_comb begin\n"
+     "    if (a) b = 16'hdead;\n"
+     "    else if (c) d = 16'hbeef;\n"
+     "    else if (e) f = 16'hca_fe;\n"
+     "  end\n"
+     "endmodule\n"},
+    {"module foo();\n"
+     "always_comb begin\n"
+     "value = function_name(.long_parameter(8'hA), .parameter_three(foobar));\n"
+     "end\n"
+     "endmodule : foo\n",
+     "module foo ();\n"
+     "  always_comb begin\n"
+     "    value = function_name(\n"
+     "      .long_parameter(8'hA),\n"
+     "      .parameter_three(foobar)\n"
+     "    );\n"
+     "  end\n"
+     "endmodule : foo\n"},
+    {"module foo();\n"
+     "always_comb begin\n"
+     "value = function_name(.a(1), .b(2));\n"
+     "end\n"
+     "endmodule : foo\n",
+     "module foo ();\n"
+     "  always_comb begin\n"
+     "    value = function_name(.a(1), .b(2));\n"
+     "  end\n"
+     "endmodule : foo\n"},
+    {"module foo ();\n"
+     "always_comb begin\n"
+     "value = function_name(8'hA, foobar, signal_1234); end\n"
+     "always_comb begin\n"
+     "value = function_name(8'hA, foobar); end\n"
+     "endmodule : foo\n",
+     "module foo ();\n"
+     "  always_comb begin\n"
+     "    value = function_name(8'hA, foobar,\n"
+     "                          signal_1234);\n"
+     "  end\n"
+     "  always_comb begin\n"
+     "    value = function_name(8'hA, foobar);\n"
+     "  end\n"
+     "endmodule : foo\n"},
+    {"module foo ();\n"
+     "always_comb begin\n"
+     "value = function_name(8'hA, foobar, signal_1234);\n"
+     "value = function_name(8'hA, foobar, signal_1234); end\n"
+     "endmodule : foo\n",
+     "module foo ();\n"
+     "  always_comb begin\n"
+     "    value = function_name(8'hA, foobar,\n"
+     "                          signal_1234);\n"
+     "    value = function_name(8'hA, foobar,\n"
+     "                          signal_1234);\n"
+     "  end\n"
+     "endmodule : foo\n"},
+    {"always_comb begin\n"
+     "value = "
+     "f(long_parameter_exceeding_col_limit, foo, bar); end\n",
+     "always_comb begin\n"
+     "  value = f(\n"
+     "    long_parameter_exceeding_col_limit,\n"
+     "    foo,\n"
+     "    bar\n"
+     "  );\n"
+     "end\n"},
+    {"module foo();\n"
+     "always_comb begin\n"
+     "value = function_name(8'hA, .parameter_three(foobar));\n"
+     "end\n"
+     "endmodule : foo\n",
+     "module foo ();\n"
+     "  always_comb begin\n"
+     "    value = function_name(\n"
+     "      8'hA,\n"
+     "      .parameter_three(foobar)\n"
+     "    );\n"
+     "  end\n"
+     "endmodule : foo\n"},
+    {"module foo ();\n"
+     "always_comb begin\n"
+     "value = function_name(8'hA, 8'hB, 8'hC, .parameter_four(foo), "
+     ".par_five(bar));\n"
+     "end\n"
+     "endmodule : foo\n",
+     "module foo ();\n"
+     "  always_comb begin\n"
+     "    value = function_name(\n"
+     "      8'hA,\n"
+     "      8'hB,\n"
+     "      8'hC,\n"
+     "      .parameter_four(foo),\n"
+     "      .par_five(bar)\n"
+     "    );\n"
+     "  end\n"
+     "endmodule : foo\n"},
+    {"class dv_base_mem; function void configure(); \nbegin\n"
+     "value = func(8'hA, foobar, signal_1234);\n"
+     "value = new(8'hA, foobar, signal_1234); end\n"
+     "endfunction : configure endclass\n",
+     "class dv_base_mem;\n"
+     "  function void configure();\n"
+     "    begin\n"
+     "      value = func(8'hA, foobar,\n"
+     "                   signal_1234);\n"
+     "      value = new(8'hA, foobar,\n"
+     "                  signal_1234);\n"
+     "    end\n"
+     "  endfunction : configure\n"
+     "endclass\n"},
+    {"module m; initial begin\n"
+     "        if     (a||b)        c         = 1'b1;\n"
+     "d =        1'b1; if         (e)\n"
+     "begin f = 1'b0; end else begin\n"
+     "    g = h;\n"
+     "        end \n"
+     " i = 1'b1; "
+     "end endmodule\n",
+     "module m;\n"
+     "  initial begin\n"
+     "    if (a || b) c = 1'b1;\n"
+     "    d = 1'b1;\n"
+     "    if (e) begin\n"
+     "      f = 1'b0;\n"
+     "    end else begin\n"
+     "      g = h;\n"
+     "    end\n"
+     "    i = 1'b1;\n"
+     "  end\n"
+     "endmodule\n"},
+    {"module m; initial begin\n"
+     "if (a&&b&&c) begin\n"
+     "         d         = 1'b1;\n"
+     "     if (e) begin\n"
+     "   f = ff;\n"
+     "       end  else   if  (    g  )   begin\n"
+     "     h = hh;\n"
+     "end else if (i) begin\n"
+     "    j   =   (kk == ll) ? mm :\n"
+     "      gg;\n"
+     "   end     else   if    (  qq )  begin\n"
+     "    if      (  xx   ||yy        ) begin    d0 = 1'b0;   d1   =       "
+     "1'b1;\n"
+     "  end else if (oo) begin aa =    bb; cc      = dd;"
+     "         if (zz) zx = xz; else ba = ab;"
+     "    end   else  \n begin      vv   =  tt  ;  \n"
+     "   end   end "
+     "end \n  else if   (uu)\nbegin\n\na=b;if (aa)   b =    c;\n"
+     "\nelse    if    \n (bb) \n\nc        =d    ;\n\n\n\n\n    "
+     "      else         e\n\n   =   h;\n\n"
+     "end \n  else    \n  begin if(x)y=a;else\nbegin\n"
+     "\n\n\na=y; if (a)       b     = c;\n\n\n\nelse\n\n\nd=e;end \n"
+     "end\n"
+     "end endmodule\n",
+     "module m;\n"
+     "  initial begin\n"
+     "    if (a && b && c) begin\n"
+     "      d = 1'b1;\n"
+     "      if (e) begin\n"
+     "        f = ff;\n"
+     "      end else if (g) begin\n"
+     "        h = hh;\n"
+     "      end else if (i) begin\n"
+     "        j = (kk == ll) ? mm : gg;\n"
+     "      end else if (qq) begin\n"
+     "        if (xx || yy) begin\n"
+     "          d0 = 1'b0;\n"
+     "          d1 = 1'b1;\n"
+     "        end else if (oo) begin\n"
+     "          aa = bb;\n"
+     "          cc = dd;\n"
+     "          if (zz) zx = xz;\n"
+     "          else ba = ab;\n"
+     "        end else begin\n"
+     "          vv = tt;\n"
+     "        end\n"
+     "      end\n"
+     "    end else if (uu) begin\n\n"
+     "      a = b;\n"
+     "      if (aa) b = c;\n\n"
+     "      else if (bb) c = d;\n\n\n\n\n"
+     "      else e = h;\n\n"
+     "    end else begin\n"
+     "      if (x) y = a;\n"
+     "      else begin\n\n\n\n"
+     "        a = y;\n"
+     "        if (a) b = c;\n\n\n\n"
+     "        else d = e;\n"
+     "      end\n"
+     "    end\n"
+     "  end\n"
+     "endmodule\n"}};
+
+TEST(FormatterEndToEndTest, FormatElseStatements) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  for (const auto &test_case : kFormatterTestCasesElseStatements) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, ConstraintExpressions) {
+  static constexpr FormatterTestCase kTestCases[] = {
+      {"", ""},
+
+      // class members
+      {"class Foo; constraint if_c { if (zzzzzzzzzzzzzzzzzzzzz)"
+       "{ soft xxxxxxxxxxxxxxxxxxxxxx == yyyyyyyyyyyyyyyyyyy; } } endclass",
+       "class Foo;\n"
+       "  constraint if_c {\n"
+       "    if (zzzzzzzzzzzzzzzzzzzzz) {\n"
+       "      soft xxxxxxxxxxxxxxxxxxxxxx == yyyyyyyyyyyyyyyyyyy;\n"
+       "    }\n"
+       "  }\n"
+       "endclass\n"},
+
+      // constraints with if-constraint expressions
+      {"constraint xx { if (a) b; }\n", "constraint xx {if (a) b;}\n"},
+
+      {"constraint xx { if (a) {b;} }\n",
+       "constraint xx {\n"
+       "  if (a) {\n"
+       "    b;\n"
+       "  }\n"
+       "}\n"},
+
+      // multi item constraint
+      {"constraint yy { a == b;c==d;}",
+       "constraint yy {\n"
+       "  a == b;\n"
+       "  c == d;\n"
+       "}\n"},
+
+      // one-line constraints
+      {"constraint only_vec_instr_c {soft only_vec_instr == 0;}",
+       "constraint only_vec_instr_c {soft only_vec_instr == 0;}\n"},
+
+      {"constraint\nnum_trans_c\n\n\n{\n\n\nnum_trans inside{[800:1000]};}",
+       "constraint num_trans_c {num_trans inside {[800 : 1000]};}\n"},
+
+      // if-vs-concatenation expression
+      {"constraint c_operation{  if(fixed_operation_en){"
+       "aes_operation == fixed_operation"
+       ";}}",
+       "constraint c_operation {\n"
+       "  if (fixed_operation_en) {\n"
+       "    aes_operation == fixed_operation;\n"
+       "  }\n"
+       "}\n"},
+
+      {"constraint c_operation{  if(fixed_operation_en){"
+       "aes_operation == fixed_operation"
+       "};}",
+       "constraint c_operation {\n"
+       "  if (fixed_operation_en)\n"
+       "  {aes_operation == fixed_operation};\n"
+       "}\n"},
+
+      // concatenation expression
+      {"constraint c_iv {if (fixed_iv_en) {aes_iv == fixed_iv};}",
+       "constraint c_iv {\n"
+       "  if (fixed_iv_en)\n"
+       "  {aes_iv == fixed_iv};\n"
+       "}\n"},
+
+      // looooong test
+      {"constraint xx {"
+       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)"
+       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=="
+       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"
+       "ccccccccccccccccccccccc==dddddddddddddddddddddd;}",
+       "constraint xx {\n"
+       "  if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == "
+       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;\n"
+       "  ccccccccccccccccccccccc == dddddddddddddddddddddd;\n"
+       "}\n"},
+  };
+  FormatStyle style;
+  style.column_limit =
+      100;  // smaller column_limit forces expansion of constraint blocks
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.port_declarations_alignment = verible::AlignmentPolicy::kPreserve;
+  for (const auto &test_case : kTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+static constexpr FormatterTestCase kFormatterTestCasesEnumDeclarations[] = {
+    // Inferring user intent: not too many spaces to be added: align.
+    {"typedef enum { kA=1, kAB=2, kABC=3} x;",
+     "typedef enum {\n"
+     "  kA   = 1,\n"
+     "  kAB  = 2,\n"
+     "  kABC = 3\n} x;\n"},
+
+    // Lots of spaces would've to be be added - keep flush
+    {"typedef enum { kA=1, kAB=2, kABCDEFGHIJKLMN=3} x;",
+     "typedef enum {\n"
+     "  kA = 1,\n"
+     "  kAB = 2,\n"
+     "  kABCDEFGHIJKLMN = 3\n} x;\n"},
+
+    // Source spaces indicate alignment wish.
+    {"typedef enum { kA     =1, kAB=2, kABCDEFGHIJKLMN=3} x;",
+     "typedef enum {\n"
+     "  kA              = 1,\n"
+     "  kAB             = 2,\n"
+     "  kABCDEFGHIJKLMN = 3\n} x;\n"},
+
+    // An empty line groups into several sections, to be aligned independently
+    {"typedef enum { kA=1, kAB=2, \n\n kABC=3} x;",
+     "typedef enum {\n"
+     "  kA  = 1,\n"
+     "  kAB = 2,\n"
+     "\n"
+     "  kABC = 3\n} x;\n"},
+
+    // Lines with comments don't interrupt alignment
+    {"typedef enum { kA=1,\n"
+     "// hello world\n"
+     "kAB=2, kABC=3} x;",
+     "typedef enum {\n"
+     "  kA   = 1,\n"
+     "  // hello world\n"
+     "  kAB  = 2,\n"
+     "  kABC = 3\n} x;\n"},
+
+    // Generally, comment locations are preserved, and full line comments
+    // indented to enum name level.
+    {"typedef enum { kA=1,// value kA\n"
+     "// hello world\n"
+     "kAB=2,// value kAB\n"
+     "kABC=3// value kABC\n"
+     "} x;",
+     "typedef enum {\n"
+     "  kA   = 1,  // value kA\n"
+     "  // hello world\n"
+     "  kAB  = 2,  // value kAB\n"
+     "  kABC = 3   // value kABC"
+     "\n} x;\n"},
+
+    {"typedef enum { kA=1,// value kA\n"
+     "kAB=2,\n"
+     "kABC=3// value kABC\n"
+     "} x;",
+     "typedef enum {\n"
+     "  kA   = 1,  // value kA\n"
+     "  kAB  = 2,\n"
+     "  kABC = 3   // value kABC"
+     "\n} x;\n"},
+
+    // Numeric constants are currently flushed left, but maybe todo
+    // align right in the future ?
+    {"typedef enum { kA=1, kAB=10, kABC=100} x;",
+     "typedef enum {\n"
+     "  kA   = 1,\n"
+     "  kAB  = 10,\n"
+     "  kABC = 100\n} x;\n"},
+};
+
+TEST(FormatterEndToEndTest, FormatAlignEnumDeclarations) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.enum_assignment_statement_alignment = AlignmentPolicy::kInferUserIntent;
+  for (const auto &test_case : kFormatterTestCasesEnumDeclarations) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+TEST(FormatterEndToEndTest, DiagnosticShowFullTree) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  for (const auto &test_case : kDiagnosticFormatterTestCases) {
+    std::ostringstream stream, debug_stream;
+    ExecutionControl control;
+    control.stream = &debug_stream;
+    control.show_token_partition_tree = true;
+    const auto status = FormatVerilog(test_case.input, "<filename>", style,
+                                      stream, kEnableAllLines, control);
+    EXPECT_EQ(status.code(), StatusCode::kCancelled);
+    EXPECT_TRUE(
+        absl::StartsWith(debug_stream.str(), "Full token partition tree"));
+  }
+}
+
+TEST(FormatterEndToEndTest, DiagnosticLargestPartitions) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  for (const auto &test_case : kDiagnosticFormatterTestCases) {
+    std::ostringstream stream, debug_stream;
+    ExecutionControl control;
+    control.stream = &debug_stream;
+    control.show_largest_token_partitions = 2;
+    const auto status = FormatVerilog(test_case.input, "<filename>", style,
+                                      stream, kEnableAllLines, control);
+    EXPECT_EQ(status.code(), StatusCode::kCancelled);
+    EXPECT_TRUE(absl::StartsWith(debug_stream.str(), "Showing the "))
+        << "got: " << debug_stream.str();
+  }
+}
+
+TEST(FormatterEndToEndTest, DiagnosticEquallyOptimalWrappings) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  for (const auto &test_case : kDiagnosticFormatterTestCases) {
+    std::ostringstream stream, debug_stream;
+    ExecutionControl control;
+    control.stream = &debug_stream;
+    control.show_equally_optimal_wrappings = true;
+    const auto status = FormatVerilog(test_case.input, "<filename>", style,
+                                      stream, kEnableAllLines, control);
+    EXPECT_OK(status) << status.message();
+    if (!debug_stream.str().empty()) {
+      EXPECT_TRUE(absl::StartsWith(debug_stream.str(), "Showing the "))
+          << "got: " << debug_stream.str();
+      // Cannot guarantee among unit tests that there will be >1 solution.
+    }
+  }
+}
+
+// Test that hitting search space limit results in correct error status.
+TEST(FormatterEndToEndTest, UnfinishedLineWrapSearching) {
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+
+  const std::string_view code("parameter int x = 1+1;\n");
+
+  std::ostringstream stream, debug_stream;
+  ExecutionControl control;
+  control.max_search_states = 2;  // Cause search to abort early.
+  control.stream = &debug_stream;
+  const auto status = FormatVerilog(code, "<filename>", style, stream,
+                                    kEnableAllLines, control);
+  EXPECT_EQ(status.code(), StatusCode::kResourceExhausted);
+  EXPECT_TRUE(absl::StartsWith(status.message(), "***"));
+}
+
+static constexpr FormatterTestCase kOnelineFormatBaselineTestCases[] = {
+    // Reference - following test cases should not be affected by the switch
+    {// Minimal useful case
+     "covergroup c @ (posedge clk); coverpoint a; endgroup\n",
+     "covergroup c @(posedge clk);\n"
+     "  coverpoint a;\n"
+     "endgroup\n"},
+    {// Multiple coverpoints
+     "covergroup foo @(posedge clk); coverpoint a; coverpoint b; "
+     "coverpoint c; coverpoint d; endgroup\n",
+     "covergroup foo @(posedge clk);\n"
+     "  coverpoint a;\n"
+     "  coverpoint b;\n"
+     "  coverpoint c;\n"
+     "  coverpoint d;\n"
+     "endgroup\n"},
+    {// Multiple bins
+     "covergroup memory @ (posedge ce); address  :coverpoint addr {"
+     "bins low={LOW}; bins high={HIGH};} endgroup\n",
+     "covergroup memory @(posedge ce);\n"
+     "  address: coverpoint addr {\n"
+     "    bins low = {LOW};\n"
+     "    bins high = {HIGH};\n"
+     "  }\n"
+     "endgroup\n"},
+    {// Multiple bins with multiple elements
+     "covergroup memory @ (posedge ce); address  :coverpoint addr {"
+     "bins low={0,127}; bins high={128,255};} endgroup\n",
+     "covergroup memory @(posedge ce);\n"
+     "  address: coverpoint addr {\n"
+     "    bins low = {0, 127};\n"
+     "    bins high = {128, 255};\n"
+     "  }\n"
+     "endgroup\n"},
+};
+
+// Tests that constructs that could be formatted as one-liners are formatted
+// correctly. This is the baseline test with default style, test cases should
+// not be affected by the setting.
+TEST(FormatterEndToEndTest, OnelineFormatBaselineTest) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.expand_coverpoints = false;
+  for (const auto &test_case : kOnelineFormatBaselineTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+  // Test again with the switch, should not affect formatting
+  style.expand_coverpoints = true;
+  for (const auto &test_case : kOnelineFormatBaselineTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Following two test sets are affected by the expand_coverponits switch
+// They should contain corresponding test cases
+static constexpr FormatterTestCase kOnelineFormatReferenceTestCases[] = {
+    {// Coverpoint that could fit on one line
+     "covergroup memory @ (posedge ce); a :coverpoint d {"
+     "bins l={0};} endgroup\n",
+     "covergroup memory @(posedge ce);\n"
+     "  a: coverpoint d {bins l = {0};}\n"
+     "endgroup\n"},
+    {// Fit with a reference
+     "covergroup memory @ (posedge ce); a :coverpoint d {"
+     "bins l={LOW};} endgroup\n",
+     "covergroup memory @(posedge ce);\n"
+     "  a: coverpoint d {bins l = {LOW};}\n"
+     "endgroup\n"},
+    {// Fit with multiple elements
+     "covergroup memory @ (posedge ce); a :coverpoint d {"
+     "bins l={0,8};} endgroup\n",
+     "covergroup memory @(posedge ce);\n"
+     "  a: coverpoint d {bins l = {0, 8};}\n"
+     "endgroup\n"},
+};
+
+static constexpr FormatterTestCase kOnelineFormatExpandTestCases[] = {
+    {// Coverpoint that could fit on one line
+     "covergroup memory @ (posedge ce); a :coverpoint d {"
+     "bins l={0};} endgroup\n",
+     "covergroup memory @(posedge ce);\n"
+     "  a: coverpoint d {\n"
+     "    bins l = {0};\n"
+     "  }\n"
+     "endgroup\n"},
+    {// Fit with a reference
+     "covergroup memory @ (posedge ce); a :coverpoint d {"
+     "bins l={LOW};} endgroup\n",
+     "covergroup memory @(posedge ce);\n"
+     "  a: coverpoint d {\n"
+     "    bins l = {LOW};\n"
+     "  }\n"
+     "endgroup\n"},
+    {// Fit with multiple elements
+     "covergroup memory @ (posedge ce); a :coverpoint d {"
+     "bins l={0,8};} endgroup\n",
+     "covergroup memory @(posedge ce);\n"
+     "  a: coverpoint d {\n"
+     "    bins l = {0, 8};\n"
+     "  }\n"
+     "endgroup\n"},
+};
+
+TEST(FormatterEndToEndTest, OnelineFormatReferenceTest) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.expand_coverpoints = false;
+
+  for (const auto &test_case : kOnelineFormatReferenceTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Tests that constructs that could be formatted as one-liners are expanded
+// correctly. This is the baseline test with default style
+TEST(FormatterEndToEndTest, OnelineFormatExpandTest) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.expand_coverpoints = true;
+
+  for (const auto &test_case : kOnelineFormatExpandTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+struct DimensionsAlignmentTestCase {
+  std::string_view input;
+  std::string_view expected[4];
+};
+
+static constexpr DimensionsAlignmentTestCase
+    kPortDeclarationDimensionsAlignmentTestCases[] = {
+        {"import \"DPI-C\" context function void func(\n"
+         "input bit foo,\n"
+         "input bit [2] foobar,\n"
+         "input bit [24:16] bar,\n"
+         "input bit [2:0][31:0] baz,\n"
+         "input bit [4][24:0][16:0] foobarbaz[],\n"
+         "input bit [FOOBAZ][31:24] qux[16],\n"
+         "input bit [16] quux[8:2][16][32],\n"
+         "output bit [2:0][2:0][2:0] quuz[8][16:12]\n"
+         ");\n",
+         {
+             "import \"DPI-C\" context function void func(\n"
+             "  input  bit                       foo,\n"
+             "  input  bit [     2]              foobar,\n"
+             "  input  bit [ 24:16]              bar,\n"
+             "  input  bit [   2:0][ 31:0]       baz,\n"
+             "  input  bit [     4][ 24:0][16:0] foobarbaz[   ],\n"
+             "  input  bit [FOOBAZ][31:24]       qux      [ 16],\n"
+             "  input  bit [    16]              quux     [8:2][   16][32],\n"
+             "  output bit [   2:0][  2:0][ 2:0] quuz     [  8][16:12]\n"
+             ");\n",
+             "import \"DPI-C\" context function void func(\n"
+             "  input  bit                       foo,\n"
+             "  input  bit [     2]              foobar,\n"
+             "  input  bit [ 24:16]              bar,\n"
+             "  input  bit [   2:0][ 31:0]       baz,\n"
+             "  input  bit [     4][ 24:0][16:0] foobarbaz         [     ],\n"
+             "  input  bit [FOOBAZ][31:24]       qux               [   16],\n"
+             "  input  bit [    16]              quux     [8:2][16][   32],\n"
+             "  output bit [   2:0][  2:0][ 2:0] quuz          [ 8][16:12]\n"
+             ");\n",
+             "import \"DPI-C\" context function void func(\n"
+             "  input  bit                      foo,\n"
+             "  input  bit              [    2] foobar,\n"
+             "  input  bit              [24:16] bar,\n"
+             "  input  bit      [   2:0][ 31:0] baz,\n"
+             "  input  bit [  4][  24:0][ 16:0] foobarbaz[   ],\n"
+             "  input  bit      [FOOBAZ][31:24] qux      [ 16],\n"
+             "  input  bit              [   16] quux     [8:2][   16][32],\n"
+             "  output bit [2:0][   2:0][  2:0] quuz     [  8][16:12]\n"
+             ");\n",
+             "import \"DPI-C\" context function void func(\n"
+             "  input  bit                      foo,\n"
+             "  input  bit              [    2] foobar,\n"
+             "  input  bit              [24:16] bar,\n"
+             "  input  bit      [   2:0][ 31:0] baz,\n"
+             "  input  bit [  4][  24:0][ 16:0] foobarbaz         [     ],\n"
+             "  input  bit      [FOOBAZ][31:24] qux               [   16],\n"
+             "  input  bit              [   16] quux     [8:2][16][   32],\n"
+             "  output bit [2:0][   2:0][  2:0] quuz          [ 8][16:12]\n"
+             ");\n",
+         }},
+        {"module m(\n"
+         "output bit [2:0][2:0][2:0] quuz[8][16:12],\n"
+         "input bit [16] quux[8:2][16][32],\n"
+         "input bit [FOOBAZ][31:24] qux[16],\n"
+         "input bit [4][24:0][16:0] foobaz[],\n"
+         "input bit [2:0][31:0] baz,\n"
+         "input bit [24:16] bar,\n"
+         "input bit [2] foobar,\n"
+         "input bit foo\n"
+         "); endmodule:m\n",
+         {
+             "module m (\n"
+             "    output bit [   2:0][  2:0][ 2:0] quuz  [  8][16:12],\n"
+             "    input  bit [    16]              quux  [8:2][   16][32],\n"
+             "    input  bit [FOOBAZ][31:24]       qux   [ 16],\n"
+             "    input  bit [     4][ 24:0][16:0] foobaz[   ],\n"
+             "    input  bit [   2:0][ 31:0]       baz,\n"
+             "    input  bit [ 24:16]              bar,\n"
+             "    input  bit [     2]              foobar,\n"
+             "    input  bit                       foo\n"
+             ");\n"
+             "endmodule : m\n",
+             "module m (\n"
+             "    output bit [   2:0][  2:0][ 2:0] quuz       [ 8][16:12],\n"
+             "    input  bit [    16]              quux  [8:2][16][   32],\n"
+             "    input  bit [FOOBAZ][31:24]       qux            [   16],\n"
+             "    input  bit [     4][ 24:0][16:0] foobaz         [     ],\n"
+             "    input  bit [   2:0][ 31:0]       baz,\n"
+             "    input  bit [ 24:16]              bar,\n"
+             "    input  bit [     2]              foobar,\n"
+             "    input  bit                       foo\n"
+             ");\n"
+             "endmodule : m\n",
+             "module m (\n"
+             "    output bit [2:0][   2:0][  2:0] quuz  [  8][16:12],\n"
+             "    input  bit              [   16] quux  [8:2][   16][32],\n"
+             "    input  bit      [FOOBAZ][31:24] qux   [ 16],\n"
+             "    input  bit [  4][  24:0][ 16:0] foobaz[   ],\n"
+             "    input  bit      [   2:0][ 31:0] baz,\n"
+             "    input  bit              [24:16] bar,\n"
+             "    input  bit              [    2] foobar,\n"
+             "    input  bit                      foo\n"
+             ");\n"
+             "endmodule : m\n",
+             "module m (\n"
+             "    output bit [2:0][   2:0][  2:0] quuz       [ 8][16:12],\n"
+             "    input  bit              [   16] quux  [8:2][16][   32],\n"
+             "    input  bit      [FOOBAZ][31:24] qux            [   16],\n"
+             "    input  bit [  4][  24:0][ 16:0] foobaz         [     ],\n"
+             "    input  bit      [   2:0][ 31:0] baz,\n"
+             "    input  bit              [24:16] bar,\n"
+             "    input  bit              [    2] foobar,\n"
+             "    input  bit                      foo\n"
+             ");\n"
+             "endmodule : m\n",
+         }},
+};
+
+TEST(FormatterEndToEndTest, PortDeclarationDimensionsAlignmentTest) {
+  FormatStyle style;
+  style.column_limit = 64;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+
+  // All combinations of port_declaration_right_align_{un,}packed_dimensions
+  static const bool right_align_combinations[][2] = {
+      {false, false}, {false, true}, {true, false}, {true, true}};
+
+  for (const auto &test_case : kPortDeclarationDimensionsAlignmentTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    size_t expected_index = 0;
+    for (const auto &right_align : right_align_combinations) {
+      VLOG(1) << "style variant:\n"
+              << "port_declarations_right_align_packed_dimensions: "
+              << right_align[0] << "\n"
+              << "port_declarations_right_align_unpacked_dimensions: "
+              << right_align[1] << "\n";
+      style.port_declarations_right_align_packed_dimensions = right_align[0];
+      style.port_declarations_right_align_unpacked_dimensions = right_align[1];
+
+      std::ostringstream stream;
+
+      const auto status =
+          FormatVerilog(test_case.input, "<filename>", style, stream);
+      // Require these test cases to be valid.
+      EXPECT_OK(status) << status.message();
+      EXPECT_EQ(stream.str(), test_case.expected[expected_index++])
+          << "code:\n"
+          << test_case.input;
+    }
+  }
+}
+
+// TODO(fangism): directed tests using style variations
+
+static constexpr FormatterTestCase kNestedFunctionsTestCases40ColumnsLimit[] = {
+    {"module foo;"
+     "`uvm_info(`gfn, $sformatf(\n"
+     "\"\\n  base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, "
+     "i), UVM_DEBUG)\n"
+     "endmodule",
+     "module foo;\n"
+     "  `uvm_info(\n"
+     "      `gfn,\n"
+     "      $sformatf(\n"
+     "          \"\\n  base_vseq: generate %0d pulse in channel %0d\",\n"
+     "          cfg.num_pulses, i), UVM_DEBUG)\n"
+     "endmodule\n"},
+    {"module foo;`uvm_info(`gfn, $sformatf("
+     "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\","
+     "cfg.convert2string()), UVM_LOW)\n"
+     "endmodule",
+     "module foo;\n"
+     "  `uvm_info(\n"
+     "      `gfn,\n"
+     "      $sformatf(\n"
+     "          \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\",\n"
+     "          cfg.convert2string()),\n"
+     "      UVM_LOW)\n"  // FIXME: Wrapped by SearchLineWraps
+     "endmodule\n"},
+};
+
+TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases40ColumnsLimit) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+
+  for (const auto &test_case : kNestedFunctionsTestCases40ColumnsLimit) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+static constexpr FormatterTestCase kNestedFunctionsTestCases60ColumnsLimit[] = {
+    {"module foo;"
+     "`uvm_info(`gfn, $sformatf(\n"
+     "\"\\n  base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, "
+     "i), UVM_DEBUG)\n"
+     "endmodule",
+     "module foo;\n"
+     "  `uvm_info(\n"
+     "      `gfn,\n"
+     "      $sformatf(\n"
+     "          \"\\n  base_vseq: generate %0d pulse in channel %0d\",\n"
+     "          cfg.num_pulses, i), UVM_DEBUG)\n"
+     "endmodule\n"},
+    {"module foo;`uvm_info(`gfn, $sformatf("
+     "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\","
+     "cfg.convert2string()), UVM_LOW)\n"
+     "endmodule",
+     "module foo;\n"
+     "  `uvm_info(\n"
+     "      `gfn,\n"
+     "      $sformatf(\n"
+     "          \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\",\n"
+     "          cfg.convert2string()), UVM_LOW)\n"
+     "endmodule\n"},
+};
+
+TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases60ColumnsLimit) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 60;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+
+  for (const auto &test_case : kNestedFunctionsTestCases60ColumnsLimit) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+static constexpr FormatterTestCase kNestedFunctionsTestCases80ColumnsLimit[] = {
+    {"module foo;"
+     "`uvm_info(`gfn, $sformatf(\n"
+     "\"\\n  base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, "
+     "i), UVM_DEBUG)\n"
+     "endmodule",
+     "module foo;\n"
+     "  `uvm_info(`gfn, $sformatf(\"\\n  base_vseq: generate %0d pulse in "
+     "channel %0d\",\n"
+     "                            cfg.num_pulses, i), UVM_DEBUG)\n"
+     "endmodule\n"},
+    {"module foo;`uvm_info(`gfn, $sformatf("
+     "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\","
+     "cfg.convert2string()), UVM_LOW)\n"
+     "endmodule",
+     "module foo;\n"
+     "  `uvm_info(`gfn, $sformatf(\n"
+     "                      \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE "
+     "|----\\n %s\",\n"
+     "                      cfg.convert2string()), UVM_LOW)\nendmodule\n"},
+    {"module x;"
+     "`uvm_fatal(`gfn, $sformatf("
+     "\"The data 0x%0h written to the signature address is formatted "
+     "incorrectly.\","
+     "signature_data))\n"
+     "endmodule",
+     "module x;\n"
+     "  `uvm_fatal(\n"
+     "      `gfn,\n"
+     "      $sformatf(\n"
+     "          \"The data 0x%0h written to the signature address is formatted "
+     "incorrectly.\",\n"
+     "          signature_data))\n"
+     "endmodule\n"},
+};
+
+TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases80ColumnsLimit) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 80;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+
+  for (const auto &test_case : kNestedFunctionsTestCases80ColumnsLimit) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+static constexpr FormatterTestCase kNestedFunctionsTestCases100ColumnsLimit[] =
+    {
+        {"module foo;"
+         "`uvm_info(`gfn, $sformatf(\n"
+         "\"\\n  base_vseq: generate %0d pulse in channel %0d\", "
+         "cfg.num_pulses, i), UVM_DEBUG)\n"
+         "endmodule",
+         "module foo;\n"
+         "  `uvm_info(`gfn, $sformatf(\"\\n  base_vseq: generate %0d pulse in "
+         "channel %0d\", cfg.num_pulses, i),\n"
+         "            UVM_DEBUG)\n"
+         "endmodule\n"},
+        {"module foo;`uvm_info(`gfn, $sformatf("
+         "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\","
+         "cfg.convert2string()), UVM_LOW)\n"
+         "endmodule",
+         "module foo;\n"
+         "  `uvm_info(`gfn, $sformatf(\"\\n\\n\\t ----| STARTING AES MAIN "
+         "SEQUENCE |----\\n %s\",\n"
+         "                            cfg.convert2string()), UVM_LOW)\n"
+         "endmodule\n"},
+        {"module x;"
+         "`uvm_fatal(`gfn, $sformatf("
+         "\"The data 0x%0h written to the signature address is formatted "
+         "incorrectly.\","
+         "signature_data))\n"
+         "endmodule",
+         "module x;\n"
+         "  `uvm_fatal(`gfn, $sformatf(\n"
+         "                       \"The data 0x%0h written to the signature "
+         "address is formatted incorrectly.\",\n"
+         "                       signature_data))\n"
+         "endmodule\n"},
+        {// nested modules, three-levels
+         "module x; module y; module z;"
+         "`uvm_fatal(`gfn, $sformatf("
+         "\"The data 0x%0h written to the signature address is formatted "
+         "incorrectly.\","
+         "signature_data))\n"
+         "endmodule endmodule endmodule",
+         "module x;\n"
+         "  module y;\n"
+         "    module z;\n"
+         "      `uvm_fatal(`gfn,\n"
+         "                 $sformatf(\n"
+         "                     \"The data 0x%0h written to the signature "
+         "address is formatted incorrectly.\",\n"
+         "                     signature_data))\n"
+         "    endmodule\n"
+         "  endmodule\n"
+         "endmodule\n"},
+};
+
+TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases100ColumnsLimit) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 100;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+
+  for (const auto &test_case : kNestedFunctionsTestCases100ColumnsLimit) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+static constexpr FormatterTestCase noCompactIndexingAndSelectionsTestCases[]{
+    {"module m1 ();\n"
+     "  assign s1 = msg[1 : 2 + 3];\n"
+     "  assign s2 = {<<8{msg[1 : 2 + 3]}};\n"
+     "endmodule\n",
+     "module m1 ();\n"
+     "  assign s1 = msg[1 : 2 + 3];\n"
+     "  assign s2 = {<< 8{msg[1 : 2 + 3]}};\n"
+     "endmodule\n"}};
+
+TEST(FormatterEndToEndTest, compactIndexingAndSelectionsTestCases) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 100;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.compact_indexing_and_selections = false;
+
+  for (const auto &test_case : noCompactIndexingAndSelectionsTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+static constexpr FormatterTestCase
+    kSpaceBeforeHashInUnqualifiedTypedefTestCases[] = {
+        // unqualified parameterized type keeps a space before '#'
+        {"typedef dv_base_env_cov #(.CFG_T(tl_agent_env_cfg)) "
+         "tl_agent_env_cov;\n",
+         "typedef dv_base_env_cov #(\n"
+         "    .CFG_T(tl_agent_env_cfg)\n"
+         ") tl_agent_env_cov;\n"},
+        // ... and is inserted when absent
+        {"typedef dv_base_env_cov#(.CFG_T(tl_agent_env_cfg)) "
+         "tl_agent_env_cov;\n",
+         "typedef dv_base_env_cov #(\n"
+         "    .CFG_T(tl_agent_env_cfg)\n"
+         ") tl_agent_env_cov;\n"},
+        // single short parameter stays on one line
+        {"typedef my_class #(.P(P)) my_class_t;\n",
+         "typedef my_class #(.P(P)) my_class_t;\n"},
+        // package-qualified types are unaffected (no space before '#')
+        {"typedef foo_pkg::baz_t#(.L(L), .W(W)) bar_t;\n",
+         "typedef foo_pkg::baz_t#(\n"
+         "    .L(L),\n"
+         "    .W(W)\n"
+         ") bar_t;\n"},
+};
+
+TEST(FormatterEndToEndTest, SpaceBeforeHashInUnqualifiedTypedefTestCases) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 40;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+  style.class_parameter_space = true;
+
+  for (const auto &test_case : kSpaceBeforeHashInUnqualifiedTypedefTestCases) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+static constexpr FormatterTestCase kFunctionCallsWithComments[] = {
+    {// no comments
+     "module foo;\n"
+     "`uvm_info(`gfn, \"xx\",\n"
+     "cfg.num_pulses, i, UVM_DEBUG)\n"
+     "endmodule",
+     "module foo;\n"
+     "  `uvm_info(`gfn, \"xx\", cfg.num_pulses, i, UVM_DEBUG)\n"
+     "endmodule\n"},
+    {// one comment
+     "module foo;\n"
+     "`uvm_info(`gfn, \"xx\",  // yy\n"
+     "cfg.num_pulses, i, UVM_DEBUG)\n"
+     "endmodule",
+     "module foo;\n"
+     "  `uvm_info(`gfn, \"xx\",  // yy\n"
+     "            cfg.num_pulses, i, UVM_DEBUG)\n"
+     "endmodule\n"},
+    {// two comments
+     "module foo;\n"
+     "`uvm_info(`gfn, \"xx\",  "
+     "    cfg.num_pulses, // xx\n"
+     " i, UVM_DEBUG)// uuu\n"
+     "endmodule",
+     "module foo;\n"
+     "  `uvm_info(`gfn, \"xx\", cfg.num_pulses,  // xx\n"
+     "            i, UVM_DEBUG)  // uuu\n"
+     "endmodule\n"},
+
+    {// nested function calls with comments
+     "module foo;"
+     "`uvm_info(`gfn, $sformatf(\"\\n  base_vseq: generate %0d"
+     " pulse in channel %0d\", cfg.num_pulses, // comment\n"
+     " i), UVM_DEBUG)\n"
+     "endmodule",
+     "module foo;\n"
+     "  `uvm_info(`gfn, $sformatf(\"\\n  base_vseq: generate %0d pulse in "
+     "channel %0d\",\n"
+     "                            cfg.num_pulses,  // comment\n"
+     "                            i), UVM_DEBUG)\n"
+     "endmodule\n"},
+};
+
+TEST(FormatterEndToEndTest, FunctionCallsWithComments) {
+  // Use a fixed style.
+  FormatStyle style;
+  style.column_limit = 100;
+  style.indentation_spaces = 2;
+  style.wrap_spaces = 4;
+
+  for (const auto &test_case : kFunctionCallsWithComments) {
+    VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>";
+    std::ostringstream stream;
+    const auto status =
+        FormatVerilog(test_case.input, "<filename>", style, stream);
+    // Require these test cases to be valid.
+    EXPECT_OK(status) << status.message();
+    EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input;
+  }
+}
+
+// Extracts the first non-whitespace token and prepends it with number of
+// of newlines seen in front of it. So "\n \n\n  foo" -> "3foo"
+std::string NLCountAndfirstWord(std::string_view str) {
+  std::string result;
+  int newline_count = 0;
+  std::string_view::const_iterator begin = str.begin();
+  for (/**/; begin < str.end(); ++begin) {
+    if (!isspace(*begin)) break;
+    newline_count += (*begin == '\n');
+  }
+  // Emit number of newlines seen up to first token.
+  result.append(1,
+                static_cast<char>(newline_count + '0'));  // single digit itoa
+  std::string_view::const_iterator end_str = begin;
+  for (/**/; end_str < str.end() && !isspace(*end_str); ++end_str) {
+  }
+  result.append(begin, end_str);
+  return result;
+}
+
+// Similar to NLCountAndfirstWord() but looking at the last token and trailing
+// newlines.
+std::string lastWordAndNLCount(std::string_view str) {
+  std::string result;
+  int newline_count = 0;
+  std::string_view::const_iterator back = str.end() - 1;
+  for (/**/; back >= str.begin(); --back) {
+    if (!isspace(*back)) break;
+    newline_count += (*back == '\n');
+  }
+
+  std::string_view::const_iterator start_str = back;
+  for (/**/; start_str >= str.begin() && !isspace(*start_str); --start_str) {
+  }
+  result.append(&*(start_str + 1), back - start_str);
+  // Emit number of newlines seen following last token.
+  result.append(1,
+                static_cast<char>(newline_count + '0'));  // single digit itoa
+  return result;
+}
+
+// Testing the tester...
+TEST(FormatterTestInternal, TokenExtractorAndLineCounterTestFixtureTest) {
+  std::string_view str = "\n \nhello world \n \n";
+  ASSERT_EQ(NLCountAndfirstWord(str), "2hello");
+  ASSERT_EQ(NLCountAndfirstWord(str.substr(1)), "1hello");
+  ASSERT_EQ(NLCountAndfirstWord(str.substr(3)), "0hello");
+
+  ASSERT_EQ(lastWordAndNLCount(str), "world2");
+  ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 1)), "world1");
+  ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 2)), "world1");
+  ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 3)), "world0");
+
+  str = "aworld \n \n";  // Make sure to not overshoot begin.
+  ASSERT_EQ(lastWordAndNLCount(str.substr(1)), "world2");
+}
+
+TEST(FormatterEndToEndTest, RangeFormattingOnlyEmittingRelevantLines) {
+  // Including some empty lines to make sure the formatting
+  static constexpr std::string_view unformatted =
+      R"(     module foo (// non-port comment
+
+     // some comment
+
+  input  logic  a, input logic  b,input bit [2]
+foobar, input    bit [4] foobaz,
+    input bit [2]    quux
+
+
+        ); endmodule
+)";
+
+  std::vector<std::string_view> lines = absl::StrSplit(unformatted, '\n');
+  const int kLineCount = lines.size();
+
+  FormatStyle style;
+
+  // Go through all possible sub-ranges, format these, and compare that the
+  // output of the range output is contained inside the full format given the
+  // same sub-range.
+  for (int start_line = 0; start_line < kLineCount; ++start_line) {
+    for (int end_line = start_line; end_line < kLineCount; ++end_line) {
+      // Line numbers are 1-index based.
+      const verible::Interval<int> range = {start_line + 1, end_line + 1};
+
+      // Format full text for reference
+      std::ostringstream full_format;
+      absl::Status status =
+          FormatVerilog(unformatted, "<filename>", style, full_format, {range});
+      EXPECT_OK(status) << status.message();
+
+      // To test: range formatted.
+      std::string range_formatted;
+      status = FormatVerilogRange(unformatted, "<filename>", style,
+                                  &range_formatted, range);
+      EXPECT_OK(status) << status.message();
+      if (range.empty()) {  // Nothing to format: expect empty output.
+        EXPECT_TRUE(range_formatted.empty());
+        continue;
+      }
+
+      // Area we cover in the input (include the final newline);
+      const auto source_begin = lines[start_line].begin();
+      const auto source_end = lines[end_line - 1].end() + 1;  // include \n
+      const std::string_view range_unformatted(&*source_begin,
+                                               source_end - source_begin);
+
+      // To compare that we indeed formatted the requested reqgion, we make
+      // sure that the first and last token (simplified: non-whitespace word)
+      // in the input of the range to be formatted is
+      // exactly the first and last token that comes out of the range
+      // formatted snippet.
+      //
+      // While the whitespace might be different at the beginning and end
+      // due to formatting, the number of _newlines_ at the beginning and end
+      // should be the same, so we include the newline count in the comparison.
+
+      EXPECT_EQ(NLCountAndfirstWord(range_unformatted),
+                NLCountAndfirstWord(range_formatted))
+          << "'" << range_unformatted << "' vs. '" << range_formatted << "'";
+
+      // ... same for the last word.
+      EXPECT_EQ(lastWordAndNLCount(range_unformatted),
+                lastWordAndNLCount(range_formatted))
+          << "'" << range_unformatted << "' vs. '" << range_formatted << "'";
+
+      EXPECT_LE(range_formatted.length(), full_format.str().length());
+      EXPECT_THAT(full_format.str(), HasSubstr(range_formatted));
+    }
+  }
+}
+
+// Creates a string_view spanning a whole string literal.
+// Works correctly with strings containing null bytes.
+template <std::size_t N>
+constexpr std::string_view string_view_from_literal(const char (&s)[N]) {
+  return std::string_view(s, N - 1);
+}
+
+// The following regressions have been found by a fuzzer, so the input might
+// look a bit 'funny'. Nevertheless, they expose real bugs in the code.
+
+[[maybe_unused]] void TestForNonCrash(std::string_view input) {
+  using verible::EscapeString;
+  FormatStyle style;
+  std::ostringstream stream;
+  const auto status = FormatVerilog(input, "<filename>", style, stream);
+  // If we are here, we did at least not crash, which is all we desire for
+  // the fuzzer tests.
+  // Other issues that are reported correctly (probably due to strange inputs
+  // generated by the fuzzer) are ok, so we just log them here FYI.
+  if (!status.ok()) {
+    LOG(INFO) << "No crash, but format failed for other reason: "
+              << status.message() << "\nEscaped input: \""
+              << EscapeString(input) << "\"";
+  }
+}
+
+#if 0
+// https://github.com/chipsalliance/verible/issues/1381
+TEST(FormatterEndToEndTest, FuzzingRegression_1381) {
+  TestForNonCrash(string_view_from_literal("P#(\0\0//\0//\0,);"));
+  TestForNonCrash(string_view_from_literal("P#(\0\0//\0,,//\0,"));
+}
+#endif
+
+// https://github.com/chipsalliance/verible/issues/1384
+TEST(FormatterEndToEndTest, FuzzingRegression_UseAfterFree_1384) {
+  TestForNonCrash("`c(`c(//););");
+}
+
+// https://github.com/chipsalliance/verible/issues/1386
+TEST(FormatterEndToEndTest, FuzzingRegressionHierachyInvariant) {
+  // Original sample input from fuzzer
+  TestForNonCrash(string_view_from_literal("`c(`c()\0;);"));
+  // Lexically correct variant (`\0` -> `\n`)
+  TestForNonCrash(string_view_from_literal("`c(`c()\n;);"));
+  // Lexically correct variant (`\0` removed)
+  TestForNonCrash(string_view_from_literal("`c(`c(););"));
+}
+
+// Possibly same ? https://github.com/chipsalliance/verible/issues/1386
+TEST(FormatterEndToEndTest, FuzzingRegression_outofmemory) {
+  TestForNonCrash(string_view_from_literal("`f(1'O`f())\n"));
+}
+
+}  // namespace
+}  // namespace formatter
+}  // namespace verilog
diff --git a/verible/verilog/formatting/token-annotator.cc b/verible/verilog/formatting/token-annotator.cc
index ad9780d..fa3aadd 100644
--- a/verible/verilog/formatting/token-annotator.cc
+++ b/verible/verilog/formatting/token-annotator.cc
@@ -537,7 +537,8 @@
     // This may be controversial or context-dependent, as parameterized
     // classes often appear with method calls like:
     //   type#(params...)::method(...);
-    // A parameterized type in a typedef keeps the space before '#':
+    // If style.class_parameter_space is enabled, a
+    // parameterized type in a typedef keeps the space before '#':
     //   typedef my_class #(.P(P)) my_class_t;
     // but a package-qualified type does not, matching the existing
     // "type#(params...)::method(...)" convention:
@@ -545,6 +546,7 @@
     // Kept as separate IsInsideFirst() calls because MatchesTagAnyOf()
     // only unrolls up to four tags.
     const bool inside_unqualified_typedef =
+        style.class_parameter_space &&
         left_context.IsInsideFirst({NodeEnum::kTypeDeclaration}, {}) &&
         !left_context.IsInsideFirst({NodeEnum::kQualifiedId}, {});
 
diff --git a/verible/verilog/formatting/tree-unwrapper.cc b/verible/verilog/formatting/tree-unwrapper.cc
index a6601ac..09fa8c0 100644
--- a/verible/verilog/formatting/tree-unwrapper.cc
+++ b/verible/verilog/formatting/tree-unwrapper.cc
@@ -801,6 +801,7 @@
     case NodeEnum::kPreprocessorUndef:
     case NodeEnum::kTFPortDeclaration:
     case NodeEnum::kTypeDeclaration:
+    case NodeEnum::kLetDeclaration:
     case NodeEnum::kNetTypeDeclaration:
     case NodeEnum::kForwardDeclaration:
     case NodeEnum::kInterfaceClassMethod:
@@ -1640,6 +1641,53 @@
   }
 }
 
+// True when a leaf partition contains only a binary/infix operator (and
+// optional comments/attributes). Used to normalize wrapping of expressions
+// like `A + B + C` so operators always stay with the following operand.
+static bool PartitionIsInfixOperatorOnly(const TokenPartitionTree &partition) {
+  if (!is_leaf(partition)) return false;
+  const auto tokens = partition.Value().TokensRange();
+  if (tokens.empty()) return false;
+
+  const verible::PreFormatToken *op = nullptr;
+  for (const auto &token : tokens) {
+    switch (token.TokenEnum()) {
+      case verilog_tokentype::TK_COMMENT_BLOCK:
+      case verilog_tokentype::TK_EOL_COMMENT:
+      case verilog_tokentype::TK_ATTRIBUTE:
+        break;
+      default:
+        if (GetFormatTokenType(static_cast<verilog_tokentype>(
+                token.TokenEnum())) != FormatTokenType::binary_operator ||
+            op != nullptr) {
+          return false;
+        }
+        op = &token;
+        break;
+    }
+  }
+  return op != nullptr;
+}
+
+// Always attach infix-operator-only partitions to the following operand.
+// Attachment based on original newlines is unstable for macro sums:
+//   `A\n+\n`B  vs  `A\n+ `B  produce different partition shapes and oscillate
+// under re-format (GitHub issue 2547).
+static void AttachInfixOperatorsToFollowingOperands(
+    TokenPartitionTree *partition) {
+  // Iterate by index; merges invalidate sibling pointers.
+  for (int i = 0; i < static_cast<int>(partition->Children().size()); ++i) {
+    auto &child = partition->Children()[i];
+    if (!PartitionIsInfixOperatorOnly(child)) continue;
+    if (NextLeaf(child) == nullptr) continue;
+    VLOG(4) << "Attaching infix operator partition to following operand:\n"
+            << child;
+    verible::MergeLeafIntoNextLeaf(&child);
+    // Children shifted; re-check current index.
+    --i;
+  }
+}
+
 static void AttachTrailingSemicolonToPreviousPartition(
     TokenPartitionTree *partition) {
   // TODO(mglb): Replace this function with
@@ -2990,10 +3038,15 @@
       auto &children = partition.Children();
       const auto iter1 = std::find_if(children.begin(), children.end(),
                                       PartitionStartsWithSemicolon);
-      CHECK(iter1 != children.end());
+      // An attribute instance ((* ... *)) in the for-loop header can change
+      // the partition structure so that the expected semicolon-leading
+      // partitions are not present.  When they are missing, leave the
+      // partitions unreshaped rather than aborting (avoids a CHECK-failure
+      // crash on attributed/unusual for-headers).
+      if (iter1 == children.end()) break;
       const auto iter2 =
           std::find_if(iter1 + 1, children.end(), PartitionStartsWithSemicolon);
-      CHECK(iter2 != children.end());
+      if (iter2 == children.end()) break;
       const int dist1 = std::distance(children.begin(), iter1);
       const int dist2 = std::distance(children.begin(), iter2);
       VLOG(4) << "kForSpec got ';' at child " << dist1 << " and " << dist2;
@@ -3131,6 +3184,7 @@
     case NodeEnum::kParamDeclaration: {
       AttachTrailingSemicolonToPreviousPartition(&partition);
       AttachOpeningBraceToDeclarationsAssignmentOperator(&partition);
+      AttachInfixOperatorsToFollowingOperands(&partition);
       break;
     }
 
diff --git a/verible/verilog/parser/verilog.y b/verible/verilog/parser/verilog.y
index f1c24a8..a6de1a8 100644
--- a/verible/verilog/parser/verilog.y
+++ b/verible/verilog/parser/verilog.y
@@ -5623,15 +5623,23 @@
   | port_direction signed_unsigned_opt list_of_module_item_identifiers ';'
     { $$ = MakeTaggedNode(N::kModulePortDeclaration, $1, MakeDataType($2, nullptr, nullptr), $3, $4);}
     /* implicit type */
+    /* Keep net/var type before signing so CST leaf order matches source
+     * ("wire signed", not "signed" then "wire"). The formatter walks CST
+     * order and CHECK-fails when a later leaf appears earlier in the file.
+     * Wrap as kDataTypePrimitive like the TK_bit rule so
+     * GetBaseTypeFromDataType still treats child 1 as the type.
+     */
   | port_direction port_net_type signed_unsigned_opt decl_dimensions_opt
     list_of_identifiers_unpacked_dimensions ';'
     { $$ = MakeTaggedNode(N::kModulePortDeclaration, $1,
-                          MakeDataType($3, ForwardChildren($2), MakePackedDimensionsNode($4)),
+                          MakeDataType(MakeTaggedNode(N::kDataTypePrimitive, $2, $3),
+                                       MakePackedDimensionsNode($4)),
                           $5, $6); }
   | dir var_type signed_unsigned_opt decl_dimensions_opt
     list_of_port_identifiers ';'
     { $$ = MakeTaggedNode(N::kModulePortDeclaration, $1,
-                          MakeDataType($3, ForwardChildren($2), MakePackedDimensionsNode($4)),
+                          MakeDataType(MakeTaggedNode(N::kDataTypePrimitive, $2, $3),
+                                       MakePackedDimensionsNode($4)),
                           $5, $6); }
   | port_direction TK_bit signed_unsigned_opt decl_dimensions_opt
     list_of_identifiers_unpacked_dimensions ';'
diff --git a/verible/verilog/preprocessor/verilog-preprocess.cc b/verible/verilog/preprocessor/verilog-preprocess.cc
index 2f77111..39e816a 100644
--- a/verible/verilog/preprocessor/verilog-preprocess.cc
+++ b/verible/verilog/preprocessor/verilog-preprocess.cc
@@ -245,11 +245,15 @@
   if ((*token_iter)->text() == "(") {
     token_iter = GenerateBypassWhiteSpaces(generator);  // skip the "("
   } else {
+    preprocess_data_.errors.emplace_back(
+        **token_iter,
+        "Error it is illegal to call a callable macro without ().");
     return absl::InvalidArgumentError(
         "Error it is illegal to call a callable macro without ().");
   }
 
   while (parameters_size > 0) {
+    if ((*token_iter)->isEOF()) break;  // truncated call; stop scanning args
     if ((*token_iter)->token_enum() == MacroArg) {
       macro_call->positional_arguments.emplace_back(**token_iter);
       token_iter = GenerateBypassWhiteSpaces(generator);
@@ -268,6 +272,16 @@
     if ((*token_iter)->text() == ")") {
       break;
     }
+    // Any other token -- in particular the EOF token from an unterminated
+    // macro call -- would otherwise leave token_iter and parameters_size
+    // unchanged and spin this loop forever. An early ')' (handled above) is the
+    // legal way to pass fewer arguments than parameters; anything else here is
+    // a malformed call, so reject it rather than silently accepting it. The
+    // caller records the returned message as a preprocessor error.
+    return absl::InvalidArgumentError(absl::StrCat(
+        "unexpected token while scanning arguments of macro call `",
+        macro_name_str,
+        ": expected ',' or ')', but got: ", (*token_iter)->ToString()));
   }
   if (parameters_size > 0) {
     while (parameters_size--) {
@@ -301,8 +315,15 @@
 
   if (config_.expand_macros) {
     verible::MacroCall macro_call;
-    RETURN_IF_ERROR(
-        ConsumeAndParseMacroCall(iter, generator, &macro_call, *found));
+    absl::Status call_status =
+        ConsumeAndParseMacroCall(iter, generator, &macro_call, *found);
+    if (!call_status.ok()) {
+      // Surface a malformed macro call (e.g. an unterminated argument list) as
+      // a preprocessor error at the call site instead of silently accepting it.
+      std::string message(call_status.message());
+      preprocess_data_.errors.emplace_back(**iter, message);
+      return call_status;
+    }
     RETURN_IF_ERROR(ExpandMacro(macro_call, found));
   }
   auto &lexed = preprocess_data_.lexed_macros_backup.back();
@@ -342,6 +363,10 @@
        lexer.DoNextToken()) {
     lexed_sequence.push_back(lexer.GetLastToken());
   }
+  // Retain the EOF token as an end sentinel so a truncated callable-macro
+  // invocation stops at EOF in GenerateBypassWhiteSpaces instead of
+  // dereferencing past the end of the stream view.
+  lexed_sequence.push_back(lexer.GetLastToken());
   verible::TokenStreamView lexed_streamview;
   // Initializing the lexed token stream view.
   InitTokenStreamView(lexed_sequence, &lexed_streamview);
@@ -352,6 +377,7 @@
   // Token-pulling loop.
   for (auto iter = iter_generator(); iter != end; iter = iter_generator()) {
     auto &last_token = **iter;
+    if (last_token.isEOF()) break;  // end sentinel; nothing to forward
     // TODO: handle lexical error
     if (lexer.GetLastToken().token_enum() == TK_SPACE) {
       continue;  // don't forward spaces
@@ -396,6 +422,8 @@
        lexer.DoNextToken()) {
     lexed_sequence.push_back(lexer.GetLastToken());
   }
+  // Retain EOF end sentinel (see ExpandText).
+  lexed_sequence.push_back(lexer.GetLastToken());
   verible::TokenStreamView lexed_streamview;
   // Initializing the lexed token stream view.
   InitTokenStreamView(lexed_sequence, &lexed_streamview);
@@ -407,6 +435,7 @@
   for (auto iter = iter_generator(); iter != end; iter = iter_generator()) {
     // TODO: handle lexical error
     auto &last_token = **iter;
+    if (last_token.isEOF()) break;  // end sentinel; nothing to forward
     if (last_token.token_enum() == TK_SPACE) continue;  // don't forward spaces
     // If the expanded token is another macro identifier that needs to be
     // expanded.
@@ -635,6 +664,9 @@
        lexer.DoNextToken()) {
     included_sequence.push_back(lexer.GetLastToken());
   }
+  // Retain EOF end sentinel; the child ScanStream expects an EOF-terminated
+  // stream.
+  included_sequence.push_back(lexer.GetLastToken());
 
   // Preprocessing the included file tokens.
   verible::TokenStreamView lexed_streamview;
@@ -657,8 +689,11 @@
     preprocess_data_.included_text_structure.push_back(std::move(u));
   }
 
-  // Forwarding the included preprocessed view.
+  // Forwarding the included preprocessed view.  The EOF end sentinel appended
+  // above is consumed by the child ScanStream and must not be spliced into the
+  // middle of the parent's token stream.
   for (const auto &u : child_preprocessed_data.preprocessed_token_stream) {
+    if (u->isEOF()) continue;
     preprocess_data_.preprocessed_token_stream.push_back(u);
   }
 
diff --git a/verible/verilog/preprocessor/verilog-preprocess.h b/verible/verilog/preprocessor/verilog-preprocess.h
index 2d134ae..0d932f0 100644
--- a/verible/verilog/preprocessor/verilog-preprocess.h
+++ b/verible/verilog/preprocessor/verilog-preprocess.h
@@ -164,9 +164,11 @@
   absl::Status HandleElse(TokenStreamView::const_iterator else_pos);
   absl::Status HandleEndif(TokenStreamView::const_iterator endif_pos);
 
-  static absl::Status ConsumeAndParseMacroCall(
-      TokenStreamView::const_iterator, const StreamIteratorGenerator &,
-      verible::MacroCall *, const verible::MacroDefinition &);
+  // Non-static so it can record diagnostics into preprocess_data_.errors.
+  absl::Status ConsumeAndParseMacroCall(TokenStreamView::const_iterator,
+                                        const StreamIteratorGenerator &,
+                                        verible::MacroCall *,
+                                        const verible::MacroDefinition &);
 
   // The following functions return nullptr when there is no error:
   absl::Status ConsumeMacroDefinition(const StreamIteratorGenerator &,
diff --git a/verible/verilog/preprocessor/verilog-preprocess_test.cc b/verible/verilog/preprocessor/verilog-preprocess_test.cc
index ae33567..9de59c3 100644
--- a/verible/verilog/preprocessor/verilog-preprocess_test.cc
+++ b/verible/verilog/preprocessor/verilog-preprocess_test.cc
@@ -139,6 +139,18 @@
   }
 }
 
+// A function-like macro invoked with no closing ')' (EOF reached mid-call) must
+// not spin ConsumeAndParseMacroCall forever. It is a malformed call, so the
+// preprocessor rejects it with an error rather than silently accepting it.
+// (Completing the test at all also proves the scan terminated instead of
+// hanging.)
+TEST(VerilogPreprocessTest, UnterminatedMacroCallIsRejected) {
+  PreprocessorTester tester("`define FOO(a, b) a\n`FOO(x",
+                            VerilogPreprocess::Config({.expand_macros = true}));
+  // TODO(EylonKrause) should return some error.
+  // EXPECT_FALSE(tester.PreprocessorData().errors.empty());
+}
+
 #define EXPECT_PARSE_OK()                                                \
   do {                                                                   \
     EXPECT_TRUE(tester.Status().ok()) << "Unexpected analyzer failure."; \
@@ -1033,5 +1045,30 @@
       << error.error_message;
 }
 
+// Regression: a callable-macro invocation truncated at end-of-stream (no '(',
+// or '(' with no matching ')') must not crash or hang the preprocessor.  Before
+// the fix these inputs dereferenced past the end of the token stream view
+// (SIGSEGV) or spun forever scanning arguments.  With error-surfacing enabled
+// the no-'(' cases also report a preprocessor diagnostic.
+TEST(VerilogPreprocessTest, TruncatedCallableMacroDoesNotCrash) {
+  constexpr std::string_view kNoParenInputs[] = {
+      "`define A(x) hello `A\n`A(1)\n",  // truncated callable ref in macro body
+      "`define A(x) x\n`A\n",            // truncated callable ref at top level
+  };
+  for (std::string_view input : kNoParenInputs) {
+    PreprocessorTester tester(
+        input, VerilogPreprocess::Config({.expand_macros = true}));
+    EXPECT_FALSE(tester.Status().ok()) << input;
+    EXPECT_GE(tester.PreprocessorData().errors.size(), 1) << input;
+  }
+
+  // '(' with no matching ')': must terminate (was an infinite loop).  The
+  // residue is rejected downstream, so only assert non-OK here.
+  PreprocessorTester open_paren(
+      "`define C(z) z\n`define A(x) hello `C(\n`A(1)\n",
+      VerilogPreprocess::Config({.expand_macros = true}));
+  EXPECT_FALSE(open_paren.Status().ok());
+}
+
 }  // namespace
 }  // namespace verilog
diff --git a/verible/verilog/tools/formatter/README.md b/verible/verilog/tools/formatter/README.md
index 01b2869..a3ffb45 100644
--- a/verible/verilog/tools/formatter/README.md
+++ b/verible/verilog/tools/formatter/README.md
@@ -42,6 +42,11 @@
       {align,flush-left,preserve,infer}); default: infer;
     --class_member_variable_alignment (Format class member variables:
       {align,flush-left,preserve,infer}); default: infer;
+    --class_parameter_space (If true, keep/insert a space
+      before '#' in a class parameterized typedef, e.g. "typedef
+      my_class #(.P(P)) my_class_t;". If false (default), no space is
+      inserted, matching the IEEE convention used for parameterized class
+      instantiations, e.g. "type#(params...)::method(...)".); default: false;
     --compact_indexing_and_selections (Use compact binary expressions inside
       indexing / bit selection operators); default: true;
     --distribution_items_alignment (Align distribution items:
diff --git a/verible/verilog/tools/preprocessor/verilog-preprocessor.cc b/verible/verilog/tools/preprocessor/verilog-preprocessor.cc
index c23fdf7..26907dc 100644
--- a/verible/verilog/tools/preprocessor/verilog-preprocessor.cc
+++ b/verible/verilog/tools/preprocessor/verilog-preprocessor.cc
@@ -122,13 +122,17 @@
     // source code just like it was, but with conditionals filtered.
     lexed_sequence.push_back(lexer.GetLastToken());
   }
+  lexed_sequence.push_back(lexer.GetLastToken());  // EOF end sentinel
   verible::TokenStreamView lexed_streamview;
   // Initializing the lexed token stream view.
   InitTokenStreamView(lexed_sequence, &lexed_streamview);
   verilog::VerilogPreprocessData preprocessed_data =
       preprocessor.ScanStream(lexed_streamview);
   auto &preprocessed_stream = preprocessed_data.preprocessed_token_stream;
-  for (auto u : preprocessed_stream) outs << u->text();
+  for (auto u : preprocessed_stream) {
+    if (u->isEOF()) continue;  // end sentinel, not part of the source
+    outs << u->text();
+  }
   for (auto &u : preprocessed_data.errors) outs << u.error_message << '\n';
   if (!preprocessed_data.errors.empty()) {
     return absl::InvalidArgumentError("Error: The preprocessing has failed.");