verilog/tools/ls/symbol-table-handler_test.cc - third_party/verible - Git at Google

 // Copyright 2017-2023 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/tools/ls/symbol-table-handler.h"

 #include <filesystem>
 #include <memory>
 #include <optional>
 #include <string>
 #include <vector>

 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "common/lsp/lsp-file-utils.h"
 #include "common/lsp/lsp-protocol.h"
 #include "common/lsp/lsp-text-buffer.h"
 #include "common/util/file_util.h"
 #include "gtest/gtest.h"
 #include "verilog/analysis/verilog_project.h"
 #include "verilog/tools/ls/lsp-parse-buffer.h"

 namespace verilog {
 namespace {

 static constexpr absl::string_view  //
     kSampleModuleA(
         R"(module a;
   assign var1 = 1'b0;
   assign var2 = var1 | 1'b1;
 endmodule
 )");

 static constexpr absl::string_view  //
     kSampleModuleB(
         R"(module b;
   assign var1 = 1'b0;
   assign var2 = var1 | 1'b1;
   a vara;
   assign vara.var1 = 1'b1;
 endmodule
 )");

 // Tests the behavior of SymbolTableHandler for not existing directory.
 TEST(SymbolTableHandlerTest, InitializationNoRoot) {
   std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
       "non-existing-root", std::vector<std::string>());

   SymbolTableHandler symbol_table_handler;

   symbol_table_handler.SetProject(project);
 }

 // Tests the behavior of SymbolTableHandler for an empty directory.
 TEST(SymbolTableHandlerTest, EmptyDirectoryProject) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   std::shared_ptr<VerilogProject> project =
       std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>());

   SymbolTableHandler symbol_table_handler;

   symbol_table_handler.SetProject(project);

   symbol_table_handler.BuildProjectSymbolTable();
 }

 TEST(SymbolTableHandlerTest, NullVerilogProject) {
   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(nullptr);
 }

 TEST(SymbolTableHandlerTest, InvalidFileListSyntax) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   const verible::file::testing::ScopedTestFile filelist(sources_dir, "@@",
                                                         "verible.filelist");

   std::shared_ptr<VerilogProject> project =
       std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>());

   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(project);

   symbol_table_handler.BuildProjectSymbolTable();
 }

 TEST(SymbolTableHandlerTest, LoadFileList) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   absl::string_view filelist_content =
       "a.sv\n"
       "b.sv\n";

   const verible::file::testing::ScopedTestFile filelist(
       sources_dir, filelist_content, "verible.filelist");
   const verible::file::testing::ScopedTestFile module_a(sources_dir,
                                                         kSampleModuleA, "a.sv");
   const verible::file::testing::ScopedTestFile module_b(sources_dir,
                                                         kSampleModuleB, "b.sv");

   std::shared_ptr<VerilogProject> project =
       std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>{});

   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(project);

   std::vector<absl::Status> diagnostics =
       symbol_table_handler.BuildProjectSymbolTable();
   ASSERT_EQ(diagnostics.size(), 0);
 }

 TEST(SymbolTableHandlerTest, FileListWithNonExistingFile) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   absl::string_view filelist_content =
       "a.sv\n"
       "b.sv\n";

   const verible::file::testing::ScopedTestFile filelist(
       sources_dir, filelist_content, "verible.filelist");
   const verible::file::testing::ScopedTestFile module_a(sources_dir,
                                                         kSampleModuleA, "a.sv");

   std::shared_ptr<VerilogProject> project =
       std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>{});

   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(project);

   std::vector<absl::Status> diagnostics =
       symbol_table_handler.BuildProjectSymbolTable();
   ASSERT_EQ(diagnostics.size(), 1);
 }

 TEST(SymbolTableHandlerTest, MissingFileList) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   const verible::file::testing::ScopedTestFile module_a(sources_dir,
                                                         kSampleModuleA, "a.sv");
   const verible::file::testing::ScopedTestFile module_b(sources_dir,
                                                         kSampleModuleB, "b.sv");

   std::shared_ptr<VerilogProject> project =
       std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>{});

   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(project);

   std::vector<absl::Status> diagnostics =
       symbol_table_handler.BuildProjectSymbolTable();
   ASSERT_EQ(diagnostics.size(), 0);
 }

 TEST(SymbolTableHandlerTest, DefinitionNotTrackedFile) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   absl::string_view filelist_content =
       "a.sv\n"
       "b.sv\n";

   const verible::file::testing::ScopedTestFile filelist(
       sources_dir, filelist_content, "verible.filelist");
   const verible::file::testing::ScopedTestFile module_a(sources_dir,
                                                         kSampleModuleA, "a.sv");
   const verible::file::testing::ScopedTestFile module_b(sources_dir,
                                                         kSampleModuleB, "b.sv");

   std::shared_ptr<VerilogProject> project =
       std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>{});

   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(project);

   verible::lsp::DefinitionParams gotorequest;
   gotorequest.textDocument.uri = "file://b.sv";
   gotorequest.position.line = 2;
   gotorequest.position.character = 17;

   std::vector<absl::Status> diagnostics =
       symbol_table_handler.BuildProjectSymbolTable();

   verilog::BufferTrackerContainer parsed_buffers;
   parsed_buffers.FindBufferTrackerOrNull(gotorequest.textDocument.uri);
   EXPECT_EQ(
       parsed_buffers.FindBufferTrackerOrNull(gotorequest.textDocument.uri),
       nullptr);

   std::vector<verible::lsp::Location> location =
       symbol_table_handler.FindDefinitionLocation(gotorequest, parsed_buffers);
   EXPECT_EQ(location.size(), 0);
 }

 TEST(SymbolTableHandlerTest,
      FindRenamableRangeAtCursorReturnsNullUntrackedFile) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   absl::string_view filelist_content = "b.sv\n";

   const verible::file::testing::ScopedTestFile filelist(
       sources_dir, filelist_content, "verible.filelist");
   const verible::file::testing::ScopedTestFile module_a(sources_dir,
                                                         kSampleModuleA, "a.sv");
   const verible::file::testing::ScopedTestFile module_b(sources_dir,
                                                         kSampleModuleB, "b.sv");
   verible::lsp::PrepareRenameParams parameters;
   parameters.textDocument.uri =
       verible::lsp::PathToLSPUri(sources_dir + "/c.sv");
   parameters.position.line = 1;
   parameters.position.character = 11;

   std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
   std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
       sources_dir, std::vector<std::string>(), "");
   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(project);

   verilog::BufferTrackerContainer parsed_buffers;
   parsed_buffers.AddChangeListener(
       symbol_table_handler.CreateBufferTrackerListener());

   // Add trackers for the files we're going to process - normally done by the
   // LSP but we don't have one
   auto a_buffer = verible::lsp::EditTextBuffer(kSampleModuleA);
   parsed_buffers.GetSubscriptionCallback()(
       verible::lsp::PathToLSPUri(sources_dir + "/a.sv"), &a_buffer);
   symbol_table_handler.BuildProjectSymbolTable();
   ASSERT_FALSE(parsed_buffers.FindBufferTrackerOrNull(
                    parameters.textDocument.uri) != nullptr);

   std::optional<verible::lsp::Range> edit_range =
       symbol_table_handler.FindRenameableRangeAtCursor(parameters,
                                                        parsed_buffers);
   ASSERT_FALSE(edit_range.has_value());
 }

 // TODO(hzeller): In the test as written, this should not work, as 'vara'
 // is of type module a, so it should complain about a null definition. However,
 // the renamable range actually returns something useful.
 // (verify: is this #1678 fixing it ?)
 TEST(SymbolTableHandlerTest,
      FindRenamableRangeAtCursorReturnsNullDefinitionUnknown) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   absl::string_view filelist_content = "b.sv\n";

   const verible::file::testing::ScopedTestFile filelist(
       sources_dir, filelist_content, "verible.filelist");
   const verible::file::testing::ScopedTestFile module_a(sources_dir,
                                                         kSampleModuleA, "a.sv");
   const verible::file::testing::ScopedTestFile module_b(sources_dir,
                                                         kSampleModuleB, "b.sv");
   verible::lsp::PrepareRenameParams parameters;
   parameters.textDocument.uri =
       verible::lsp::PathToLSPUri(sources_dir + "/b.sv");
   parameters.position.line = 3;  // pointing to 'vara'
   parameters.position.character = 5;

   std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
   std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
       sources_dir, std::vector<std::string>(), "");
   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(project);

   verilog::BufferTrackerContainer parsed_buffers;
   parsed_buffers.AddChangeListener(
       symbol_table_handler.CreateBufferTrackerListener());

   // Add trackers for the files we're going to process - normally done by the
   // LSP but we don't have one
   auto b_buffer = verible::lsp::EditTextBuffer(kSampleModuleB);
   parsed_buffers.GetSubscriptionCallback()(parameters.textDocument.uri,
                                            &b_buffer);
   symbol_table_handler.BuildProjectSymbolTable();
   ASSERT_TRUE(parsed_buffers.FindBufferTrackerOrNull(
                   parameters.textDocument.uri) != nullptr);

   std::optional<verible::lsp::Range> edit_range =
       symbol_table_handler.FindRenameableRangeAtCursor(parameters,
                                                        parsed_buffers);

   // This was ASSERT_FALSE(), but in fact we get the range of 'vara' back,
   // and renaming that actually works. TODO: Check intent of this test.
   ASSERT_TRUE(edit_range.has_value());
 }

 TEST(SymbolTableHandlerTest, FindRenamableRangeAtCursorReturnsLocation) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   absl::string_view filelist_content =
       "a.sv\n"
       "b.sv\n";

   const verible::file::testing::ScopedTestFile filelist(
       sources_dir, filelist_content, "verible.filelist");
   const verible::file::testing::ScopedTestFile module_a(sources_dir,
                                                         kSampleModuleA, "a.sv");
   const verible::file::testing::ScopedTestFile module_b(sources_dir,
                                                         kSampleModuleB, "b.sv");
   verible::lsp::PrepareRenameParams parameters;
   parameters.textDocument.uri =
       verible::lsp::PathToLSPUri(sources_dir + "/a.sv");
   parameters.position.line = 1;
   parameters.position.character = 11;

   std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
   std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
       sources_dir, std::vector<std::string>(), "");
   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(project);

   verilog::BufferTrackerContainer parsed_buffers;
   parsed_buffers.AddChangeListener(
       symbol_table_handler.CreateBufferTrackerListener());

   // Add trackers for the files we're going to process - normally done by the
   // LSP but we don't have one
   auto a_buffer = verible::lsp::EditTextBuffer(kSampleModuleA);
   parsed_buffers.GetSubscriptionCallback()(parameters.textDocument.uri,
                                            &a_buffer);
   symbol_table_handler.BuildProjectSymbolTable();
   ASSERT_TRUE(parsed_buffers.FindBufferTrackerOrNull(
                   parameters.textDocument.uri) != nullptr);

   std::optional<verible::lsp::Range> edit_range =
       symbol_table_handler.FindRenameableRangeAtCursor(parameters,
                                                        parsed_buffers);
   ASSERT_TRUE(edit_range.has_value());
   if (edit_range.has_value()) {  // Access after test. Makes .clang-tidy happy
     EXPECT_EQ(edit_range.value().start.line, 1);
     EXPECT_EQ(edit_range.value().start.character, 9);
   }
 }
 TEST(SymbolTableHandlerTest,
      FindRenameLocationsAndCreateEditsReturnsLocationsTest) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   absl::string_view filelist_content =
       "a.sv\n"
       "b.sv\n";

   const verible::file::testing::ScopedTestFile filelist(
       sources_dir, filelist_content, "verible.filelist");
   const verible::file::testing::ScopedTestFile module_a(sources_dir,
                                                         kSampleModuleA, "a.sv");
   const verible::file::testing::ScopedTestFile module_b(sources_dir,
                                                         kSampleModuleB, "b.sv");
   verible::lsp::RenameParams parameters;
   parameters.textDocument.uri =
       verible::lsp::PathToLSPUri(sources_dir + "/a.sv");
   parameters.position.line = 1;
   parameters.position.character = 11;
   parameters.newName = "aaa";

   std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
   std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
       sources_dir, std::vector<std::string>(), "");
   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(project);

   verilog::BufferTrackerContainer parsed_buffers;
   parsed_buffers.AddChangeListener(
       symbol_table_handler.CreateBufferTrackerListener());

   // Add trackers for the files we're going to process - normally done by the
   // LSP but we don't have one
   auto a_buffer = verible::lsp::EditTextBuffer(kSampleModuleA);
   parsed_buffers.GetSubscriptionCallback()(parameters.textDocument.uri,
                                            &a_buffer);
   symbol_table_handler.BuildProjectSymbolTable();
   ASSERT_TRUE(parsed_buffers.FindBufferTrackerOrNull(
                   parameters.textDocument.uri) != nullptr);

   verible::lsp::WorkspaceEdit edit_range =
       symbol_table_handler.FindRenameLocationsAndCreateEdits(parameters,
                                                              parsed_buffers);
   EXPECT_EQ(edit_range.changes[parameters.textDocument.uri].size(), 2);
   EXPECT_EQ(
       edit_range.changes[verible::lsp::PathToLSPUri(sources_dir + "/b.sv")]
           .size(),
       1);
 }

 TEST(SymbolTableHandlerTest,
      FindRenameLocationsAndCreateEditsReturnsLocationsOnDirtyFilesTest) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   absl::string_view filelist_content =
       "a.sv\n"
       "b.sv\n";

   const verible::file::testing::ScopedTestFile filelist(
       sources_dir, filelist_content, "verible.filelist");
   const verible::file::testing::ScopedTestFile module_a(sources_dir,
                                                         kSampleModuleA, "a.sv");
   const verible::file::testing::ScopedTestFile module_b(sources_dir,
                                                         kSampleModuleB, "b.sv");
   verible::lsp::RenameParams parameters;
   parameters.textDocument.uri =
       verible::lsp::PathToLSPUri(sources_dir + "/a.sv");
   parameters.position.line = 1;
   parameters.position.character = 11;
   parameters.newName = "aaa";

   std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
   std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
       sources_dir, std::vector<std::string>(), "");
   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(project);

   verilog::BufferTrackerContainer parsed_buffers;
   parsed_buffers.AddChangeListener(
       symbol_table_handler.CreateBufferTrackerListener());

   // Add trackers for the files we're going to process - normally done by the
   // LSP but we don't have one
   auto a_buffer = verible::lsp::EditTextBuffer(kSampleModuleA);
   parsed_buffers.GetSubscriptionCallback()(parameters.textDocument.uri,
                                            &a_buffer);
   symbol_table_handler.BuildProjectSymbolTable();
   ASSERT_TRUE(parsed_buffers.FindBufferTrackerOrNull(
                   parameters.textDocument.uri) != nullptr);

   verible::lsp::WorkspaceEdit edit_range =
       symbol_table_handler.FindRenameLocationsAndCreateEdits(parameters,
                                                              parsed_buffers);
   EXPECT_EQ(edit_range.changes[parameters.textDocument.uri].size(), 2);
   EXPECT_EQ(
       edit_range.changes[verible::lsp::PathToLSPUri(sources_dir + "/b.sv")]
           .size(),
       1);

   parameters.newName = "bbb";

   edit_range = symbol_table_handler.FindRenameLocationsAndCreateEdits(
       parameters, parsed_buffers);
   EXPECT_EQ(edit_range.changes[parameters.textDocument.uri].size(), 2);
   EXPECT_EQ(
       edit_range.changes[verible::lsp::PathToLSPUri(sources_dir + "/b.sv")]
           .size(),
       1);
 }

 TEST(SymbolTableHandlerTest, UpdateWithUnparseableEditorContentRegression) {
   const auto tempdir = ::testing::TempDir();
   const std::string sources_dir =
       verible::file::JoinPath(tempdir, __FUNCTION__);
   ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

   absl::string_view filelist_content = "";
   const verible::file::testing::ScopedTestFile filelist(
       sources_dir, filelist_content, "verible.filelist");
   const std::string uri = verible::lsp::PathToLSPUri(sources_dir + "/a.sv");
   std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
   std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
       sources_dir, std::vector<std::string>(), "");
   SymbolTableHandler symbol_table_handler;
   symbol_table_handler.SetProject(project);

   verilog::BufferTrackerContainer parsed_buffers;
   parsed_buffers.AddChangeListener(
       symbol_table_handler.CreateBufferTrackerListener());

   // We want to make sure that every change updates the project file with
   // the latest content.
   //
   // The verilog_project would react badly if it gets the exact same content
   // twice, as it would want to register its string_view locations in its
   // reverse map.
   //
   // If we'd filter to only send 'last_good()' content, which stays the same
   // while we have bad content, we'd attempt to register the same range.
   // multiple times with the project.
   //
   // So walking through the sequence good content (sets current() and
   // last_good()), parse error content (sets only current(), but leaves
   // last_good() as-is), and good content again (replaces current() as well
   // as last_good()), we make sure that this sequence will work.
   // Give our file list a valid content
   auto a_buffer = verible::lsp::EditTextBuffer(kSampleModuleA);
   a_buffer.set_last_global_version(1);
   parsed_buffers.GetSubscriptionCallback()(uri, &a_buffer);

   // Now, the content in the editor becomes invalid.
   auto broken_buffer = verible::lsp::EditTextBuffer("invalid-file");
   broken_buffer.set_last_global_version(2);
   parsed_buffers.GetSubscriptionCallback()(uri, &broken_buffer);

   // ... back to a valid parsed file. This replaces the previously broken file.
   a_buffer.set_last_global_version(3);
   parsed_buffers.GetSubscriptionCallback()(uri, &a_buffer);
 }

 TEST(SymbolTableHandlerTest, MissingVerilogProject) {
   SymbolTableHandler symbol_table_handler;
   std::vector<absl::Status> diagnostics =
       symbol_table_handler.BuildProjectSymbolTable();

   ASSERT_EQ(diagnostics.size(), 1);
   ASSERT_FALSE(diagnostics[0].ok());
 }

 }  // namespace
 }  // namespace verilog
	// Copyright 2017-2023 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/tools/ls/symbol-table-handler.h"

	#include <filesystem>
	#include <memory>
	#include <optional>
	#include <string>
	#include <vector>

	#include "absl/status/status.h"
	#include "absl/strings/string_view.h"
	#include "common/lsp/lsp-file-utils.h"
	#include "common/lsp/lsp-protocol.h"
	#include "common/lsp/lsp-text-buffer.h"
	#include "common/util/file_util.h"
	#include "gtest/gtest.h"
	#include "verilog/analysis/verilog_project.h"
	#include "verilog/tools/ls/lsp-parse-buffer.h"

	namespace verilog {
	namespace {

	static constexpr absl::string_view //
	kSampleModuleA(
	R"(module a;
	assign var1 = 1'b0;
	assign var2 = var1 \| 1'b1;
	endmodule
	)");

	static constexpr absl::string_view //
	kSampleModuleB(
	R"(module b;
	assign var1 = 1'b0;
	assign var2 = var1 \| 1'b1;
	a vara;
	assign vara.var1 = 1'b1;
	endmodule
	)");

	// Tests the behavior of SymbolTableHandler for not existing directory.
	TEST(SymbolTableHandlerTest, InitializationNoRoot) {
	std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
	"non-existing-root", std::vector<std::string>());

	SymbolTableHandler symbol_table_handler;

	symbol_table_handler.SetProject(project);
	}

	// Tests the behavior of SymbolTableHandler for an empty directory.
	TEST(SymbolTableHandlerTest, EmptyDirectoryProject) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	std::shared_ptr<VerilogProject> project =
	std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>());

	SymbolTableHandler symbol_table_handler;

	symbol_table_handler.SetProject(project);

	symbol_table_handler.BuildProjectSymbolTable();
	}

	TEST(SymbolTableHandlerTest, NullVerilogProject) {
	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(nullptr);
	}

	TEST(SymbolTableHandlerTest, InvalidFileListSyntax) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	const verible::file::testing::ScopedTestFile filelist(sources_dir, "@@",
	"verible.filelist");

	std::shared_ptr<VerilogProject> project =
	std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>());

	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(project);

	symbol_table_handler.BuildProjectSymbolTable();
	}

	TEST(SymbolTableHandlerTest, LoadFileList) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	absl::string_view filelist_content =
	"a.sv\n"
	"b.sv\n";

	const verible::file::testing::ScopedTestFile filelist(
	sources_dir, filelist_content, "verible.filelist");
	const verible::file::testing::ScopedTestFile module_a(sources_dir,
	kSampleModuleA, "a.sv");
	const verible::file::testing::ScopedTestFile module_b(sources_dir,
	kSampleModuleB, "b.sv");

	std::shared_ptr<VerilogProject> project =
	std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>{});

	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(project);

	std::vector<absl::Status> diagnostics =
	symbol_table_handler.BuildProjectSymbolTable();
	ASSERT_EQ(diagnostics.size(), 0);
	}

	TEST(SymbolTableHandlerTest, FileListWithNonExistingFile) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	absl::string_view filelist_content =
	"a.sv\n"
	"b.sv\n";

	const verible::file::testing::ScopedTestFile filelist(
	sources_dir, filelist_content, "verible.filelist");
	const verible::file::testing::ScopedTestFile module_a(sources_dir,
	kSampleModuleA, "a.sv");

	std::shared_ptr<VerilogProject> project =
	std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>{});

	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(project);

	std::vector<absl::Status> diagnostics =
	symbol_table_handler.BuildProjectSymbolTable();
	ASSERT_EQ(diagnostics.size(), 1);
	}

	TEST(SymbolTableHandlerTest, MissingFileList) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	const verible::file::testing::ScopedTestFile module_a(sources_dir,
	kSampleModuleA, "a.sv");
	const verible::file::testing::ScopedTestFile module_b(sources_dir,
	kSampleModuleB, "b.sv");

	std::shared_ptr<VerilogProject> project =
	std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>{});

	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(project);

	std::vector<absl::Status> diagnostics =
	symbol_table_handler.BuildProjectSymbolTable();
	ASSERT_EQ(diagnostics.size(), 0);
	}

	TEST(SymbolTableHandlerTest, DefinitionNotTrackedFile) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	absl::string_view filelist_content =
	"a.sv\n"
	"b.sv\n";

	const verible::file::testing::ScopedTestFile filelist(
	sources_dir, filelist_content, "verible.filelist");
	const verible::file::testing::ScopedTestFile module_a(sources_dir,
	kSampleModuleA, "a.sv");
	const verible::file::testing::ScopedTestFile module_b(sources_dir,
	kSampleModuleB, "b.sv");

	std::shared_ptr<VerilogProject> project =
	std::make_shared<VerilogProject>(sources_dir, std::vector<std::string>{});

	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(project);

	verible::lsp::DefinitionParams gotorequest;
	gotorequest.textDocument.uri = "file://b.sv";
	gotorequest.position.line = 2;
	gotorequest.position.character = 17;

	std::vector<absl::Status> diagnostics =
	symbol_table_handler.BuildProjectSymbolTable();

	verilog::BufferTrackerContainer parsed_buffers;
	parsed_buffers.FindBufferTrackerOrNull(gotorequest.textDocument.uri);
	EXPECT_EQ(
	parsed_buffers.FindBufferTrackerOrNull(gotorequest.textDocument.uri),
	nullptr);

	std::vector<verible::lsp::Location> location =
	symbol_table_handler.FindDefinitionLocation(gotorequest, parsed_buffers);
	EXPECT_EQ(location.size(), 0);
	}

	TEST(SymbolTableHandlerTest,
	FindRenamableRangeAtCursorReturnsNullUntrackedFile) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	absl::string_view filelist_content = "b.sv\n";

	const verible::file::testing::ScopedTestFile filelist(
	sources_dir, filelist_content, "verible.filelist");
	const verible::file::testing::ScopedTestFile module_a(sources_dir,
	kSampleModuleA, "a.sv");
	const verible::file::testing::ScopedTestFile module_b(sources_dir,
	kSampleModuleB, "b.sv");
	verible::lsp::PrepareRenameParams parameters;
	parameters.textDocument.uri =
	verible::lsp::PathToLSPUri(sources_dir + "/c.sv");
	parameters.position.line = 1;
	parameters.position.character = 11;

	std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
	std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
	sources_dir, std::vector<std::string>(), "");
	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(project);

	verilog::BufferTrackerContainer parsed_buffers;
	parsed_buffers.AddChangeListener(
	symbol_table_handler.CreateBufferTrackerListener());

	// Add trackers for the files we're going to process - normally done by the
	// LSP but we don't have one
	auto a_buffer = verible::lsp::EditTextBuffer(kSampleModuleA);
	parsed_buffers.GetSubscriptionCallback()(
	verible::lsp::PathToLSPUri(sources_dir + "/a.sv"), &a_buffer);
	symbol_table_handler.BuildProjectSymbolTable();
	ASSERT_FALSE(parsed_buffers.FindBufferTrackerOrNull(
	parameters.textDocument.uri) != nullptr);

	std::optional<verible::lsp::Range> edit_range =
	symbol_table_handler.FindRenameableRangeAtCursor(parameters,
	parsed_buffers);
	ASSERT_FALSE(edit_range.has_value());
	}

	// TODO(hzeller): In the test as written, this should not work, as 'vara'
	// is of type module a, so it should complain about a null definition. However,
	// the renamable range actually returns something useful.
	// (verify: is this #1678 fixing it ?)
	TEST(SymbolTableHandlerTest,
	FindRenamableRangeAtCursorReturnsNullDefinitionUnknown) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	absl::string_view filelist_content = "b.sv\n";

	const verible::file::testing::ScopedTestFile filelist(
	sources_dir, filelist_content, "verible.filelist");
	const verible::file::testing::ScopedTestFile module_a(sources_dir,
	kSampleModuleA, "a.sv");
	const verible::file::testing::ScopedTestFile module_b(sources_dir,
	kSampleModuleB, "b.sv");
	verible::lsp::PrepareRenameParams parameters;
	parameters.textDocument.uri =
	verible::lsp::PathToLSPUri(sources_dir + "/b.sv");
	parameters.position.line = 3; // pointing to 'vara'
	parameters.position.character = 5;

	std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
	std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
	sources_dir, std::vector<std::string>(), "");
	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(project);

	verilog::BufferTrackerContainer parsed_buffers;
	parsed_buffers.AddChangeListener(
	symbol_table_handler.CreateBufferTrackerListener());

	// Add trackers for the files we're going to process - normally done by the
	// LSP but we don't have one
	auto b_buffer = verible::lsp::EditTextBuffer(kSampleModuleB);
	parsed_buffers.GetSubscriptionCallback()(parameters.textDocument.uri,
	&b_buffer);
	symbol_table_handler.BuildProjectSymbolTable();
	ASSERT_TRUE(parsed_buffers.FindBufferTrackerOrNull(
	parameters.textDocument.uri) != nullptr);

	std::optional<verible::lsp::Range> edit_range =
	symbol_table_handler.FindRenameableRangeAtCursor(parameters,
	parsed_buffers);

	// This was ASSERT_FALSE(), but in fact we get the range of 'vara' back,
	// and renaming that actually works. TODO: Check intent of this test.
	ASSERT_TRUE(edit_range.has_value());
	}

	TEST(SymbolTableHandlerTest, FindRenamableRangeAtCursorReturnsLocation) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	absl::string_view filelist_content =
	"a.sv\n"
	"b.sv\n";

	const verible::file::testing::ScopedTestFile filelist(
	sources_dir, filelist_content, "verible.filelist");
	const verible::file::testing::ScopedTestFile module_a(sources_dir,
	kSampleModuleA, "a.sv");
	const verible::file::testing::ScopedTestFile module_b(sources_dir,
	kSampleModuleB, "b.sv");
	verible::lsp::PrepareRenameParams parameters;
	parameters.textDocument.uri =
	verible::lsp::PathToLSPUri(sources_dir + "/a.sv");
	parameters.position.line = 1;
	parameters.position.character = 11;

	std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
	std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
	sources_dir, std::vector<std::string>(), "");
	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(project);

	verilog::BufferTrackerContainer parsed_buffers;
	parsed_buffers.AddChangeListener(
	symbol_table_handler.CreateBufferTrackerListener());

	// Add trackers for the files we're going to process - normally done by the
	// LSP but we don't have one
	auto a_buffer = verible::lsp::EditTextBuffer(kSampleModuleA);
	parsed_buffers.GetSubscriptionCallback()(parameters.textDocument.uri,
	&a_buffer);
	symbol_table_handler.BuildProjectSymbolTable();
	ASSERT_TRUE(parsed_buffers.FindBufferTrackerOrNull(
	parameters.textDocument.uri) != nullptr);

	std::optional<verible::lsp::Range> edit_range =
	symbol_table_handler.FindRenameableRangeAtCursor(parameters,
	parsed_buffers);
	ASSERT_TRUE(edit_range.has_value());
	if (edit_range.has_value()) { // Access after test. Makes .clang-tidy happy
	EXPECT_EQ(edit_range.value().start.line, 1);
	EXPECT_EQ(edit_range.value().start.character, 9);
	}
	}
	TEST(SymbolTableHandlerTest,
	FindRenameLocationsAndCreateEditsReturnsLocationsTest) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	absl::string_view filelist_content =
	"a.sv\n"
	"b.sv\n";

	const verible::file::testing::ScopedTestFile filelist(
	sources_dir, filelist_content, "verible.filelist");
	const verible::file::testing::ScopedTestFile module_a(sources_dir,
	kSampleModuleA, "a.sv");
	const verible::file::testing::ScopedTestFile module_b(sources_dir,
	kSampleModuleB, "b.sv");
	verible::lsp::RenameParams parameters;
	parameters.textDocument.uri =
	verible::lsp::PathToLSPUri(sources_dir + "/a.sv");
	parameters.position.line = 1;
	parameters.position.character = 11;
	parameters.newName = "aaa";

	std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
	std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
	sources_dir, std::vector<std::string>(), "");
	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(project);

	verilog::BufferTrackerContainer parsed_buffers;
	parsed_buffers.AddChangeListener(
	symbol_table_handler.CreateBufferTrackerListener());

	// Add trackers for the files we're going to process - normally done by the
	// LSP but we don't have one
	auto a_buffer = verible::lsp::EditTextBuffer(kSampleModuleA);
	parsed_buffers.GetSubscriptionCallback()(parameters.textDocument.uri,
	&a_buffer);
	symbol_table_handler.BuildProjectSymbolTable();
	ASSERT_TRUE(parsed_buffers.FindBufferTrackerOrNull(
	parameters.textDocument.uri) != nullptr);

	verible::lsp::WorkspaceEdit edit_range =
	symbol_table_handler.FindRenameLocationsAndCreateEdits(parameters,
	parsed_buffers);
	EXPECT_EQ(edit_range.changes[parameters.textDocument.uri].size(), 2);
	EXPECT_EQ(
	edit_range.changes[verible::lsp::PathToLSPUri(sources_dir + "/b.sv")]
	.size(),
	1);
	}

	TEST(SymbolTableHandlerTest,
	FindRenameLocationsAndCreateEditsReturnsLocationsOnDirtyFilesTest) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	absl::string_view filelist_content =
	"a.sv\n"
	"b.sv\n";

	const verible::file::testing::ScopedTestFile filelist(
	sources_dir, filelist_content, "verible.filelist");
	const verible::file::testing::ScopedTestFile module_a(sources_dir,
	kSampleModuleA, "a.sv");
	const verible::file::testing::ScopedTestFile module_b(sources_dir,
	kSampleModuleB, "b.sv");
	verible::lsp::RenameParams parameters;
	parameters.textDocument.uri =
	verible::lsp::PathToLSPUri(sources_dir + "/a.sv");
	parameters.position.line = 1;
	parameters.position.character = 11;
	parameters.newName = "aaa";

	std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
	std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
	sources_dir, std::vector<std::string>(), "");
	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(project);

	verilog::BufferTrackerContainer parsed_buffers;
	parsed_buffers.AddChangeListener(
	symbol_table_handler.CreateBufferTrackerListener());

	// Add trackers for the files we're going to process - normally done by the
	// LSP but we don't have one
	auto a_buffer = verible::lsp::EditTextBuffer(kSampleModuleA);
	parsed_buffers.GetSubscriptionCallback()(parameters.textDocument.uri,
	&a_buffer);
	symbol_table_handler.BuildProjectSymbolTable();
	ASSERT_TRUE(parsed_buffers.FindBufferTrackerOrNull(
	parameters.textDocument.uri) != nullptr);

	verible::lsp::WorkspaceEdit edit_range =
	symbol_table_handler.FindRenameLocationsAndCreateEdits(parameters,
	parsed_buffers);
	EXPECT_EQ(edit_range.changes[parameters.textDocument.uri].size(), 2);
	EXPECT_EQ(
	edit_range.changes[verible::lsp::PathToLSPUri(sources_dir + "/b.sv")]
	.size(),
	1);

	parameters.newName = "bbb";

	edit_range = symbol_table_handler.FindRenameLocationsAndCreateEdits(
	parameters, parsed_buffers);
	EXPECT_EQ(edit_range.changes[parameters.textDocument.uri].size(), 2);
	EXPECT_EQ(
	edit_range.changes[verible::lsp::PathToLSPUri(sources_dir + "/b.sv")]
	.size(),
	1);
	}

	TEST(SymbolTableHandlerTest, UpdateWithUnparseableEditorContentRegression) {
	const auto tempdir = ::testing::TempDir();
	const std::string sources_dir =
	verible::file::JoinPath(tempdir, __FUNCTION__);
	ASSERT_TRUE(verible::file::CreateDir(sources_dir).ok());

	absl::string_view filelist_content = "";
	const verible::file::testing::ScopedTestFile filelist(
	sources_dir, filelist_content, "verible.filelist");
	const std::string uri = verible::lsp::PathToLSPUri(sources_dir + "/a.sv");
	std::filesystem::absolute({sources_dir.begin(), sources_dir.end()}).string();
	std::shared_ptr<VerilogProject> project = std::make_shared<VerilogProject>(
	sources_dir, std::vector<std::string>(), "");
	SymbolTableHandler symbol_table_handler;
	symbol_table_handler.SetProject(project);

	verilog::BufferTrackerContainer parsed_buffers;
	parsed_buffers.AddChangeListener(
	symbol_table_handler.CreateBufferTrackerListener());

	// We want to make sure that every change updates the project file with
	// the latest content.
	//
	// The verilog_project would react badly if it gets the exact same content
	// twice, as it would want to register its string_view locations in its
	// reverse map.
	//
	// If we'd filter to only send 'last_good()' content, which stays the same
	// while we have bad content, we'd attempt to register the same range.
	// multiple times with the project.
	//
	// So walking through the sequence good content (sets current() and
	// last_good()), parse error content (sets only current(), but leaves
	// last_good() as-is), and good content again (replaces current() as well
	// as last_good()), we make sure that this sequence will work.
	// Give our file list a valid content
	auto a_buffer = verible::lsp::EditTextBuffer(kSampleModuleA);
	a_buffer.set_last_global_version(1);
	parsed_buffers.GetSubscriptionCallback()(uri, &a_buffer);

	// Now, the content in the editor becomes invalid.
	auto broken_buffer = verible::lsp::EditTextBuffer("invalid-file");
	broken_buffer.set_last_global_version(2);
	parsed_buffers.GetSubscriptionCallback()(uri, &broken_buffer);

	// ... back to a valid parsed file. This replaces the previously broken file.
	a_buffer.set_last_global_version(3);
	parsed_buffers.GetSubscriptionCallback()(uri, &a_buffer);
	}

	TEST(SymbolTableHandlerTest, MissingVerilogProject) {
	SymbolTableHandler symbol_table_handler;
	std::vector<absl::Status> diagnostics =
	symbol_table_handler.BuildProjectSymbolTable();

	ASSERT_EQ(diagnostics.size(), 1);
	ASSERT_FALSE(diagnostics[0].ok());
	}

	} // namespace
	} // namespace verilog