// Copyright 2017-2020 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.

#include "verilog/CST/statement.h"

#include <memory>
#include <vector>

#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "common/analysis/matcher/matcher_builders.h"
#include "common/analysis/syntax_tree_search.h"
#include "common/analysis/syntax_tree_search_test_utils.h"
#include "common/text/concrete_syntax_tree.h"
#include "common/text/symbol.h"
#include "common/text/text_structure.h"
#include "common/text/token_info.h"
#include "common/text/token_info_test_util.h"
#include "common/util/casts.h"
#include "common/util/logging.h"
#include "common/util/range.h"
#include "verilog/CST/verilog_matchers.h"
#include "verilog/CST/verilog_nonterminals.h"
#include "verilog/analysis/verilog_analyzer.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 {

using verible::SymbolKind;
using verible::SymbolTag;
using verible::SyntaxTreeSearchTestCase;
using verible::TreeSearchMatch;

struct ControlStatementTestData {
  NodeEnum expected_construct;
  SyntaxTreeSearchTestCase token_data;
};

TEST(GetAnyControlStatementBodyTest, Various) {
  constexpr int kTag = 1;  // value doesn't matter
  const ControlStatementTestData kTestCases[] = {
      // each of these test cases should match exactly one statement body
      {NodeEnum::kGenerateIfClause,
       {"module m;\n"
        "  if (expr)\n",
        {kTag, ";"},  // null generate item
        "\n"
        "  else \n"
        "   bar foo;\n"
        "endmodule\n"}},
      {NodeEnum::kGenerateIfClause,
       {"module m;\n"
        "  if (expr)\n"
        "   ",
        {kTag, "foo bar;"},
        "\n"
        "  else \n"
        "   bar foo;\n"
        "endmodule\n"}},
      {NodeEnum::kGenerateIfClause,
       {"module m;\n"
        "  if (expr)\n"
        "   ",
        {kTag, "begin\nfoo bar;end"},
        "\n"
        "  else \n"
        "   bar foo;\n"
        "endmodule\n"}},

      {NodeEnum::kGenerateElseClause,
       {"module m;\n"
        "  if (expr)\n"
        "   foo bar;\n"
        "  else \n",
        {kTag, ";"},  // null generate item
        "\n"
        "endmodule\n"}},
      {NodeEnum::kGenerateElseClause,
       {"module m;\n"
        "  if (expr)\n"
        "   foo bar;\n"
        "  else \n",
        {kTag, "bar#(1)   foo;"},
        "\n"
        "endmodule\n"}},
      {NodeEnum::kGenerateElseClause,
       {"module m;\n"
        "  if (expr)\n"
        "   foo bar;\n"
        "  else \n",
        {kTag, "begin \nbar#(1)   foo; baz bam();\nend"},
        "\n"
        "endmodule\n"}},

      {NodeEnum::kLoopGenerateConstruct,
       {"module m;\n"
        "  for (genvar i=0; i<N; ++i)\n"
        "   ",
        {kTag, ";"},  // null generate item
        "\n"
        "endmodule\n"}},
      {NodeEnum::kLoopGenerateConstruct,
       {"module m;\n"
        "  for (genvar i=0; i<N; ++i)\n"
        "   ",
        {kTag, "foo#(.N(i)) bar;"},
        "\n"
        "endmodule\n"}},
      {NodeEnum::kLoopGenerateConstruct,
       {"module m;\n"
        "  for (genvar i=0; i<N; ++i)\n"
        "   ",
        {kTag, "begin:l1\n      foo#(.N(i)) bar;\n  end : l1"},
        "\n"
        "endmodule\n"}},

      {NodeEnum::kIfClause,
       {"function f;\n"
        "  if (expr)\n",
        {kTag, ";"},  // null statement
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endfunction\n"}},
      {NodeEnum::kIfClause,
       {"function f;\n"
        "  if (expr)\n"
        "   ",
        {kTag, "foo=bar;"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endfunction\n"}},
      {NodeEnum::kIfClause,
       {"task t;\n"
        "  if (expr)\n"
        "   ",
        {kTag, "begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endtask\n"}},

      {NodeEnum::kElseClause,
       {"task t;\n"
        "  if (expr)\n"
        "   foo =bar;\n"
        "\n"
        "  else\n",
        {kTag, "bar=foo;"},
        "endtask\n"}},
      {NodeEnum::kElseClause,
       {"task t;\n"
        "  if (expr)\n"
        "   foo =bar;\n"
        "\n"
        "  else\n",
        {kTag, ";"},  // null statement
        "endtask\n"}},
      {NodeEnum::kElseClause,
       {"function f;\n"
        "  if (expr)\n"
        "   foo =bar;\n"
        "  else\n",
        {kTag, "begin:bb bar=foo(baz);\n\nend :\nbb"},
        "\nendfunction\n"}},

      {NodeEnum::kForLoopStatement,
       {"function f;\n"
        "  for (int j=N; expr; --j)\n"
        "   ",
        {kTag, ";"},  // null statement
        "\n"
        "endfunction\n"}},
      {NodeEnum::kForLoopStatement,
       {"function f;\n"
        "  for (int j=N; expr; --j)\n"
        "   ",
        {kTag, "foo=bar;"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kForLoopStatement,
       {"task t;\n"
        "  for (int j=N; expr; --j)\n"
        "   ",
        {kTag, "begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kDoWhileLoopStatement,
       {"function f;\n"
        "   do\n",
        {kTag, ";"},  // null statement
        "  while (expr);\n"
        "endfunction\n"}},
      {NodeEnum::kDoWhileLoopStatement,
       {"function f;\n"
        "   do\n",
        {kTag, "foo=bar;"},
        "  while (expr);\n"
        "endfunction\n"}},
      {NodeEnum::kDoWhileLoopStatement,
       {"task t;\n"
        "  do ",
        {kTag, "begin\nfoo=bar; bar=1;\nend"},
        "  while (expr);\n"
        "endtask\n"}},

      {NodeEnum::kForeverLoopStatement,
       {"function f;\n"
        "  forever\n",
        {kTag, ";"},  // null statement
        "\n"
        "endfunction\n"}},
      {NodeEnum::kForeverLoopStatement,
       {"function f;\n"
        "  forever\n"
        "   ",
        {kTag, "foo=bar;"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kForeverLoopStatement,
       {"task t;\n"
        "  forever\n"
        "   ",
        {kTag, "begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kForeachLoopStatement,
       {"function f;\n"
        "  foreach (x[i])\n",
        {kTag, ";"},  // null statement
        "\n"
        "endfunction\n"}},
      {NodeEnum::kForeachLoopStatement,
       {"function f;\n"
        "  foreach (x[i])\n"
        "   ",
        {kTag, "foo=bar;"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kForeachLoopStatement,
       {"task t;\n"
        "  foreach (x[i])\n"
        "   ",
        {kTag, "begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kRepeatLoopStatement,
       {"function f;\n"
        "  repeat (8)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endfunction\n"}},
      {NodeEnum::kRepeatLoopStatement,
       {"function f;\n"
        "  repeat (8)\n"
        "   ",
        {kTag, "foo=bar;"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kRepeatLoopStatement,
       {"task t;\n"
        "  repeat (9)\n"
        "   ",
        {kTag, "begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kWhileLoopStatement,
       {"function f;\n"
        "  while (expr)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endfunction\n"}},
      {NodeEnum::kWhileLoopStatement,
       {"function f;\n"
        "  while (expr)\n"
        "   ",
        {kTag, "foo=bar;"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kWhileLoopStatement,
       {"task t;\n"
        "  while (expr)\n"
        "   ",
        {kTag, "begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kProceduralTimingControlStatement,
       {"module  m;\n"
        "  always @(negedge c)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endmodule\n"}},
      {NodeEnum::kProceduralTimingControlStatement,
       {"module  m;\n"
        "  always @(negedge c)\n",
        {kTag, "foo=bar;"},
        "\n"
        "endmodule\n"}},
      {NodeEnum::kProceduralTimingControlStatement,
       {"module  m;\n"
        "  always @(negedge c)\n",
        {kTag, "begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "endmodule\n"}},

      {NodeEnum::kAssertionClause,
       {"task  t;\n"
        "  assert (expr)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertionClause,
       {"task  t;\n"
        "  assert (expr)\n",
        {kTag, "action();"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertionClause,
       {"task  t;\n"
        "  assert (expr)\n",
        {kTag, "begin action(); end"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kAssumeClause,
       {"task  t;\n"
        "  assume (expr)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumeClause,
       {"task  t;\n"
        "  assume (expr)\n",
        {kTag, "action();"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumeClause,
       {"task  t;\n"
        "  assume (expr)\n",
        {kTag, "begin action(); end"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kWaitStatement,
       {"task  t;\n"
        "  wait (expr)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kWaitStatement,
       {"task  t;\n"
        "  wait (expr)\n",
        {kTag, "snooze();"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kWaitStatement,
       {"task  t;\n"
        "  wait (expr)\n",
        {kTag, "begin snooze(); end"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kCoverStatement,
       {"task  t;\n"
        "  cover (expr)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kCoverStatement,
       {"task  t;\n"
        "  cover (expr)\n",
        {kTag, "snooze();"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kCoverStatement,
       {"task  t;\n"
        "  cover (expr)\n",
        {kTag, "begin snooze(); end"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kAssertPropertyClause,
       {"task  t;\n"
        "  assert property (p_expr)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertPropertyClause,
       {"task  t;\n"
        "  assert property (p_expr)\n",
        {kTag, "action();"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertPropertyClause,
       {"task  t;\n"
        "  assert property (p_expr)\n",
        {kTag, "begin action(); end"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kAssumePropertyClause,
       {"task  t;\n"
        "  assume property (p_expr)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumePropertyClause,
       {"task  t;\n"
        "  assume property (p_expr)\n",
        {kTag, "action();"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumePropertyClause,
       {"task  t;\n"
        "  assume property (p_expr)\n",
        {kTag, "begin action(); end"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kExpectPropertyClause,
       {"task  t;\n"
        "  expect (p_expr)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kExpectPropertyClause,
       {"task  t;\n"
        "  expect (p_expr)\n",
        {kTag, "action();"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kExpectPropertyClause,
       {"task  t;\n"
        "  expect (p_expr)\n",
        {kTag, "begin action(); end"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kCoverPropertyStatement,
       {"task  t;\n"
        "  cover property (p_expr)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kCoverPropertyStatement,
       {"task  t;\n"
        "  cover property (p_expr)\n",
        {kTag, "action();"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kCoverPropertyStatement,
       {"task  t;\n"
        "  cover property (p_expr)\n",
        {kTag, "begin action(); end"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kCoverSequenceStatement,
       {"task  t;\n"
        "  cover sequence (s_expr)\n",
        {kTag, ";"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kCoverSequenceStatement,
       {"task  t;\n"
        "  cover sequence (s_expr)\n",
        {kTag, "action();"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kCoverSequenceStatement,
       {"task  t;\n"
        "  cover sequence (s_expr)\n",
        {kTag, "begin action(); end"},
        "\n"
        "endtask\n"}},
  };
  for (const auto& test : kTestCases) {
    const absl::string_view code(test.token_data.code);
    VerilogAnalyzer analyzer(code, "test-file");
    const auto code_copy = analyzer.Data().Contents();
    ASSERT_OK(analyzer.Analyze()) << "failed on:\n" << code;
    const auto& root = analyzer.Data().SyntaxTree();

    // Grab outer statement constructs.
    const auto statements = verible::SearchSyntaxTree(
        *ABSL_DIE_IF_NULL(root),
        verible::matcher::DynamicTagMatchBuilder(SymbolTag{
            SymbolKind::kNode, static_cast<int>(test.expected_construct)})());

    // Extract subtree of interest.
    std::vector<TreeSearchMatch> bodies;
    for (const auto& statement : statements) {
      const auto* body = GetAnyControlStatementBody(*statement.match);
      bodies.push_back(TreeSearchMatch{body, {/* ignored context */}});
    }

    // Compare sets of text ranges.
    std::ostringstream diffs;
    EXPECT_TRUE(test.token_data.ExactMatchFindings(bodies, code_copy, &diffs))
        << "failed on:\n"
        << code << "\ndiffs:\n"
        << diffs.str();
  }
}

TEST(GetAnyConditionalIfClauseTest, Various) {
  const ControlStatementTestData kTestCases[] = {
      // each of these test cases should match exactly one statement body
      {NodeEnum::kConditionalGenerateConstruct,
       {"module m;\n",
        {static_cast<int>(NodeEnum::kGenerateIfClause), "if (expr);"},
        "\n"
        "endmodule\n"}},
      {NodeEnum::kConditionalGenerateConstruct,
       {"module m;\n",
        {static_cast<int>(NodeEnum::kGenerateIfClause), "if (expr) foo bar;"},
        "\n"
        "endmodule\n"}},
      {NodeEnum::kConditionalGenerateConstruct,
       {"module m;\n",
        {static_cast<int>(NodeEnum::kGenerateIfClause), "if (expr) foo bar;"},
        "\n"
        "  else \n"
        "   bar foo;\n"
        "endmodule\n"}},
      {NodeEnum::kConditionalGenerateConstruct,
       {"module m;\n",
        {static_cast<int>(NodeEnum::kGenerateIfClause),
         "if (expr) begin\nfoo bar;end"},
        "\n"
        "  else \n"
        "   bar foo;\n"
        "endmodule\n"}},

      {NodeEnum::kConditionalStatement,
       {"function f;\n",
        {static_cast<int>(NodeEnum::kIfClause), "if ( expr );"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kConditionalStatement,
       {"function f;\n",
        {static_cast<int>(NodeEnum::kIfClause), "if ( expr ) foo=bar;"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kConditionalStatement,
       {"function f;\n",
        {static_cast<int>(NodeEnum::kIfClause), "if ( expr ) foo=bar;"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endfunction\n"}},
      {NodeEnum::kConditionalStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kIfClause),
         "if  (expr)begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endtask\n"}},

      {NodeEnum::kAssertionStatement,
       {"function f;\n",
        {static_cast<int>(NodeEnum::kAssertionClause),
         "assert ( expr );"},  // null statement
        "\n"
        "endfunction\n"}},
      {NodeEnum::kAssertionStatement,
       {"function f;\n",
        {static_cast<int>(NodeEnum::kAssertionClause),
         "assert ( expr ) foo=bar;"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kAssertionStatement,
       {"function f;\n",
        {static_cast<int>(NodeEnum::kAssertionClause),
         "assert ( expr ) foo=bar;"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endfunction\n"}},
      {NodeEnum::kAssertionStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssertionClause),
         "assert  (expr)begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endtask\n"}},

      {NodeEnum::kAssumeStatement,
       {"function f;\n",
        {static_cast<int>(NodeEnum::kAssumeClause), "assume ( expr );"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kAssumeStatement,
       {"function f;\n",
        {static_cast<int>(NodeEnum::kAssumeClause), "assume ( expr ) foo=bar;"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kAssumeStatement,
       {"function f;\n",
        {static_cast<int>(NodeEnum::kAssumeClause), "assume ( expr ) foo=bar;"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endfunction\n"}},
      {NodeEnum::kAssumeStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssumeClause),
         "assume  (expr)begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endtask\n"}},

      {NodeEnum::kAssertPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssertPropertyClause),
         "assert property ( p_expr );"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssertPropertyClause),
         "assert property ( p_expr ) foo=bar;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssertPropertyClause),
         "assert property ( p_expr ) foo=bar;"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endtask\n"}},
      {NodeEnum::kAssertPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssertPropertyClause),
         "assert property  (p_expr)begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endtask\n"}},

      {NodeEnum::kAssumePropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssumePropertyClause),
         "assume property ( p_expr );"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumePropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssumePropertyClause),
         "assume property ( p_expr ) foo=bar;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumePropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssumePropertyClause),
         "assume property ( p_expr ) foo=bar;"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endtask\n"}},
      {NodeEnum::kAssumePropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssumePropertyClause),
         "assume property  (p_expr)begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endtask\n"}},

      {NodeEnum::kExpectPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kExpectPropertyClause),
         "expect ( p_expr );"},  // null statement
        "\n"
        "endtask\n"}},
      {NodeEnum::kExpectPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kExpectPropertyClause),
         "expect ( p_expr ) foo=bar;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kExpectPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kExpectPropertyClause),
         "expect ( p_expr ) foo=bar;"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endtask\n"}},
      {NodeEnum::kExpectPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kExpectPropertyClause),
         "expect (p_expr)begin\nfoo=bar; bar=1;\nend"},
        "\n"
        "  else \n"
        "   bar=foo;\n"
        "endtask\n"}},
  };
  for (const auto& test : kTestCases) {
    const absl::string_view code(test.token_data.code);
    VerilogAnalyzer analyzer(code, "test-file");
    const auto code_copy = analyzer.Data().Contents();
    ASSERT_OK(analyzer.Analyze()) << "failed on:\n" << code;
    const auto& root = analyzer.Data().SyntaxTree();

    // Grab outer statement constructs.
    const auto statements = verible::SearchSyntaxTree(
        *ABSL_DIE_IF_NULL(root),
        verible::matcher::DynamicTagMatchBuilder(SymbolTag{
            SymbolKind::kNode, static_cast<int>(test.expected_construct)})());

    // Extract subtree of interest.
    std::vector<TreeSearchMatch> bodies;
    for (const auto& statement : statements) {
      const auto* clause = GetAnyConditionalIfClause(*statement.match);
      bodies.push_back(TreeSearchMatch{clause, {/* ignored context */}});
    }

    // Compare sets of text ranges.
    std::ostringstream diffs;
    EXPECT_TRUE(test.token_data.ExactMatchFindings(bodies, code_copy, &diffs))
        << "failed on:\n"
        << code << "\ndiffs:\n"
        << diffs.str();
  }
}

TEST(GetAnyConditionalElseClauseTest, NoElseClause) {
  const ControlStatementTestData kTestCases[] = {
      // each of these test cases should match exactly one statement body
      {NodeEnum::kConditionalGenerateConstruct,
       {"module m;\n",
        {static_cast<int>(NodeEnum::kGenerateIfClause), "if (expr);"},
        "\n"
        "endmodule\n"}},
      {NodeEnum::kConditionalGenerateConstruct,
       {"module m;\n",
        {static_cast<int>(NodeEnum::kGenerateIfClause), "if (expr) foo bar;"},
        "\n"
        "endmodule\n"}},

      {NodeEnum::kConditionalStatement,
       {"function f;\n",
        {static_cast<int>(NodeEnum::kIfClause), "if ( expr );"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kConditionalStatement,
       {"function f;\n",
        {static_cast<int>(NodeEnum::kIfClause), "if ( expr ) foo=bar;"},
        "\n"
        "endfunction\n"}},

      {NodeEnum::kAssertionStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssertionClause), "assert ( expr );"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertionStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssertionClause),
         "assert ( expr ) foo=bar;"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kAssumeStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssumeClause), "assume ( expr );"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumeStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssumeClause), "assume ( expr ) foo=bar;"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kAssertPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssertPropertyClause),
         "assert property( expr );"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssertPropertyClause),
         "assert property ( expr ) foo=bar;"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kAssumePropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssumePropertyClause),
         "assume property( expr );"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumePropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kAssumePropertyClause),
         "assume property ( expr ) foo=bar;"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kExpectPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kExpectPropertyClause), "expect( expr );"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kExpectPropertyStatement,
       {"task t;\n",
        {static_cast<int>(NodeEnum::kExpectPropertyClause),
         "expect ( expr ) foo=bar;"},
        "\n"
        "endtask\n"}},
  };
  for (const auto& test : kTestCases) {
    const absl::string_view code(test.token_data.code);
    VerilogAnalyzer analyzer(code, "test-file");
    ASSERT_OK(analyzer.Analyze()) << "failed on:\n" << code;
    const auto& root = analyzer.Data().SyntaxTree();

    const auto statements = verible::SearchSyntaxTree(
        *ABSL_DIE_IF_NULL(root),
        verible::matcher::DynamicTagMatchBuilder(SymbolTag{
            SymbolKind::kNode, static_cast<int>(test.expected_construct)})());
    ASSERT_EQ(statements.size(), 1);
    const auto& statement = *statements.front().match;
    const auto* clause = GetAnyConditionalElseClause(statement);
    EXPECT_EQ(clause, nullptr);
  }
}

TEST(GetAnyConditionalElseClauseTest, HaveElseClause) {
  const ControlStatementTestData kTestCases[] = {
      // each of these test cases should match exactly one statement body
      {NodeEnum::kConditionalGenerateConstruct,
       {"module m;\n",
        "if (expr);\n",
        {static_cast<int>(NodeEnum::kGenerateElseClause),
         "else \n"
         "   ;"},  // null else body
        "\n"
        "endmodule\n"}},
      {NodeEnum::kConditionalGenerateConstruct,
       {"module m;\n",
        "if (expr);\n",
        {static_cast<int>(NodeEnum::kGenerateElseClause),
         "else \n"
         "   bar foo;"},
        "\n"
        "endmodule\n"}},
      {NodeEnum::kConditionalGenerateConstruct,
       {"module m;\n",
        "if (expr) foo bar;\n",
        {static_cast<int>(NodeEnum::kGenerateElseClause),
         "else \n"
         "   bar foo;"},
        "\n"
        "endmodule\n"}},
      {NodeEnum::kConditionalGenerateConstruct,
       {"module m;\n",
        "if (expr) foo bar;\n",
        {static_cast<int>(NodeEnum::kGenerateElseClause),
         "else \n"
         "   begin bar foo;\nend"},
        "\n"
        "endmodule\n"}},

      {NodeEnum::kConditionalStatement,
       {"function f;\n",
        "if ( expr );\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   ;"},  // null else body
        "\n"
        "endfunction\n"}},
      {NodeEnum::kConditionalStatement,
       {"function f;\n",
        "if ( expr );\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kConditionalStatement,
       {"function f;\n",
        "if ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endfunction\n"}},
      {NodeEnum::kConditionalStatement,
       {"function f;\n",
        "if ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   begin\nbar=foo;\nend"},
        "\n"
        "endfunction\n"}},

      {NodeEnum::kAssertionStatement,
       {"task t;\n",
        "assert ( expr )\n",  // no statement
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertionStatement,
       {"task t;\n",
        "assert ( expr );\n",  // null statement
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertionStatement,
       {"task t;\n",
        "assert ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   ;"},  // null else body
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertionStatement,
       {"task t;\n",
        "assert ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertionStatement,
       {"task t;\n",
        "assert ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   begin\nbar=foo;\nend"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kAssumeStatement,
       {"task t;\n",
        "assume ( expr )\n",  // no statement
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumeStatement,
       {"task t;\n",
        "assume ( expr );\n",  // null statement
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumeStatement,
       {"task t;\n",
        "assume ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumeStatement,
       {"task t;\n",
        "assume ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   ;"},  // null else body
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumeStatement,
       {"task t;\n",
        "assume ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   begin\nbar=foo;\nend"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kAssertPropertyStatement,
       {"task t;\n",
        "assert property ( expr )\n",  // no statement
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertPropertyStatement,
       {"task t;\n",
        "assert property ( expr );\n",  // null statement
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertPropertyStatement,
       {"task t;\n",
        "assert property ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   ;"},  // null else body
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertPropertyStatement,
       {"task t;\n",
        "assert property ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssertPropertyStatement,
       {"task t;\n",
        "assert property ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   begin\nbar=foo;\nend"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kAssumePropertyStatement,
       {"task t;\n",
        "assume property ( expr )\n",  // no statement
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumePropertyStatement,
       {"task t;\n",
        "assume property ( expr );\n",  // null statement
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumePropertyStatement,
       {"task t;\n",
        "assume property ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   ;"},  // null else body
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumePropertyStatement,
       {"task t;\n",
        "assume property ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kAssumePropertyStatement,
       {"task t;\n",
        "assume property ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   begin\nbar=foo;\nend"},
        "\n"
        "endtask\n"}},

      {NodeEnum::kExpectPropertyStatement,
       {"task t;\n",
        "expect ( expr )\n",  // no statement
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kExpectPropertyStatement,
       {"task t;\n",
        "expect ( expr );\n",  // null statement
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kExpectPropertyStatement,
       {"task t;\n",
        "expect ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   ;"},  // null else body
        "\n"
        "endtask\n"}},
      {NodeEnum::kExpectPropertyStatement,
       {"task t;\n",
        "expect ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   bar=foo;"},
        "\n"
        "endtask\n"}},
      {NodeEnum::kExpectPropertyStatement,
       {"task t;\n",
        "expect ( expr ) foo=bar;\n",
        {static_cast<int>(NodeEnum::kElseClause),
         "else \n"
         "   begin\nbar=foo;\nend"},
        "\n"
        "endtask\n"}},
  };
  for (const auto& test : kTestCases) {
    const absl::string_view code(test.token_data.code);
    VerilogAnalyzer analyzer(code, "test-file");
    const auto code_copy = analyzer.Data().Contents();
    ASSERT_OK(analyzer.Analyze()) << "failed on:\n" << code;
    const auto& root = analyzer.Data().SyntaxTree();

    // Grab outer statement constructs.
    const auto statements = verible::SearchSyntaxTree(
        *ABSL_DIE_IF_NULL(root),
        verible::matcher::DynamicTagMatchBuilder(SymbolTag{
            SymbolKind::kNode, static_cast<int>(test.expected_construct)})());

    // Extract subtree of interest.
    std::vector<TreeSearchMatch> bodies;
    for (const auto& statement : statements) {
      const auto* clause = GetAnyConditionalElseClause(*statement.match);
      bodies.push_back(TreeSearchMatch{clause, {/* ignored context */}});
    }

    // Compare sets of text ranges.
    std::ostringstream diffs;
    EXPECT_TRUE(test.token_data.ExactMatchFindings(bodies, code_copy, &diffs))
        << "failed on:\n"
        << code << "\ndiffs:\n"
        << diffs.str();
  }
}

}  // namespace
}  // namespace verilog