verilog/tools/kythe/scope_resolver_test.cc - third_party/verible - Git at Google

 // 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/tools/kythe/scope_resolver.h"

 #include <vector>

 #include "gtest/gtest.h"
 #include "verilog/tools/kythe/kythe_facts.h"

 namespace verilog {
 namespace kythe {
 namespace {

 constexpr absl::string_view names[] = {
     "signature0", "signature1", "signature2", "signature3",
     "signature4", "signature5", "signature6", "signature7",
     "signature8", "signature9", "",
 };

 static const std::vector<Signature> signatures{
     Signature(names[0]),
     Signature(names[1]),
     Signature(names[2]),
     Signature(names[3]),
     Signature(names[4]),
     Signature(Signature(names[5]), names[6]),
     Signature(Signature(Signature(names[7]), names[8]), names[9]),
     Signature(names[10]),
 };

 static const std::vector<VName> vnames{
     {.path = "", .root = "", .signature = signatures[0], .corpus = ""},
     {.path = "", .root = "", .signature = signatures[1], .corpus = ""},
     {.path = "", .root = "", .signature = signatures[2], .corpus = ""},
     {.path = "", .root = "", .signature = signatures[3], .corpus = ""},
     {.path = "", .root = "", .signature = signatures[4], .corpus = ""},
     {.path = "", .root = "", .signature = signatures[5], .corpus = ""},
     {.path = "", .root = "", .signature = signatures[6], .corpus = ""},
     {.path = "", .root = "", .signature = signatures[7], .corpus = ""},
 };

 TEST(ScopeResolverTests, ScopeResolverLinkedList) {
   /**
    * signature[0] => {
    *   vnames[1],  ==> signature[1]
    *   vnames[2],  ==> signature[2]
    * }
    */

   Scope scope(signatures[0]);
   scope.AddMemberItem(vnames[1]);
   scope.AddMemberItem(vnames[2]);

   ScopeResolver scope_resolver1(Signature("file1"), nullptr);
   scope_resolver1.MapSignatureToScope(signatures[0], scope);

   ScopeResolver scope_resolver(Signature("file2"), &scope_resolver1);
   {
     Scope global_scope(signatures[7]);
     ScopeContext::AutoPop p1(&scope_resolver.GetMutableScopeContext(),
                              &global_scope);
     scope_resolver.AddDefinitionToCurrentScope(vnames[0]);
     {
       const std::vector<std::pair<const VName*, const Scope*>> vnames =
           scope_resolver.SearchForDefinitions({names[0], names[1]});
       EXPECT_EQ(vnames.size(), 2);
       EXPECT_EQ(vnames[1].first->signature, signatures[1]);
     }
     {
       const std::vector<std::pair<const VName*, const Scope*>> vnames =
           scope_resolver.SearchForDefinitions({names[0], names[2]});
       EXPECT_EQ(vnames.size(), 2);
       EXPECT_EQ(vnames[1].first->signature, signatures[2]);
     }
     {
       const std::vector<std::pair<const VName*, const Scope*>> vnames =
           scope_resolver.SearchForDefinitions({names[0], names[3]});
       EXPECT_EQ(vnames.size(), 1);
       EXPECT_EQ(vnames[0].first->signature, signatures[0]);
     }
     {
       const std::vector<std::pair<const VName*, const Scope*>> vnames =
           scope_resolver.SearchForDefinitions({names[2], names[1]});
       EXPECT_TRUE(vnames.empty());
     }
   }
 }

 TEST(ScopesTest, AppendScope) {
   /**
    * signature[0] => {
    *   vnames[1],  ==> signature[1]
    *   vnames[2],  ==> signature[2]
    * }
    *
    * signature[1] => {
    *   vnames[3],  ==> signature[3];
    *   vnames[4],  ==> signature[4];
    * }
    */

   Scope scope(signatures[0]);
   scope.AddMemberItem(vnames[1]);
   scope.AddMemberItem(vnames[2]);

   Scope scope2(signatures[1]);
   scope2.AddMemberItem(vnames[3]);
   scope2.AddMemberItem(vnames[4]);

   scope2.AppendScope(scope);

   {
     const VName* vname = scope2.SearchForDefinition(names[1]);
     EXPECT_EQ(vname->signature, signatures[1]);
   }
   {
     const VName* vname = scope2.SearchForDefinition(names[2]);
     EXPECT_EQ(vname->signature, signatures[2]);
   }
   {
     const VName* vname = scope2.SearchForDefinition(names[3]);
     EXPECT_EQ(vname->signature, signatures[3]);
   }
   {
     const VName* vname = scope2.SearchForDefinition(names[4]);
     EXPECT_EQ(vname->signature, signatures[4]);
   }
 }

 TEST(ScopesTest, RemoveMember) {
   /**
    * signature[0] => {
    *   vnames[1],  ==> signature[1]
    *   vnames[2],  ==> signature[2]
    * }
    *
    * signature[1] => {
    *   vnames[3],  ==> signature[3];
    *   vnames[4],  ==> signature[4];
    * }
    */

   Scope scope(signatures[0]);
   scope.AddMemberItem(vnames[1]);
   scope.AddMemberItem(vnames[2]);

   {
     const VName* vname = scope.SearchForDefinition(names[1]);
     EXPECT_EQ(vname->signature, signatures[1]);
   }

   {
     scope.RemoveMember(vnames[1]);
     const VName* vname = scope.SearchForDefinition(names[1]);
     EXPECT_EQ(vname, nullptr);
   }

   {
     const VName* vname = scope.SearchForDefinition(names[2]);
     EXPECT_EQ(vname->signature, signatures[2]);
   }
 }

 TEST(ScopeResolverTests, SearchForDefinition) {
   ScopeResolver scope_resolver(Signature(""), nullptr);

   /**
    * signature[0] => {
    *   vnames[1],  ==> signature[1]
    *   vnames[2],  ==> signature[2]
    * }
    */

   Scope scope(signatures[0]);
   scope.AddMemberItem(vnames[1]);
   scope.AddMemberItem(vnames[2]);

   {
     Scope global_scope(signatures[7]);
     ScopeContext::AutoPop p1(&scope_resolver.GetMutableScopeContext(),
                              &global_scope);
     scope_resolver.AddDefinitionToCurrentScope(vnames[0]);
     scope_resolver.MapSignatureToScope(signatures[0], scope);
     {
       const std::vector<std::pair<const VName*, const Scope*>> vnames =
           scope_resolver.SearchForDefinitions({names[0], names[1]});
       EXPECT_EQ(vnames.size(), 2);
       EXPECT_EQ(vnames[1].first->signature, signatures[1]);
     }
     {
       const std::vector<std::pair<const VName*, const Scope*>> vnames =
           scope_resolver.SearchForDefinitions({names[0], names[2]});
       EXPECT_EQ(vnames.size(), 2);
       EXPECT_EQ(vnames[1].first->signature, signatures[2]);
     }
     {
       const std::vector<std::pair<const VName*, const Scope*>> vnames =
           scope_resolver.SearchForDefinitions({names[0], names[3]});
       EXPECT_EQ(vnames.size(), 1);
       EXPECT_EQ(vnames[0].first->signature, signatures[0]);
     }
     {
       const std::vector<std::pair<const VName*, const Scope*>> vnames =
           scope_resolver.SearchForDefinitions({names[2], names[1]});
       EXPECT_TRUE(vnames.empty());
     }
   }
 }

 TEST(ScopeResolverTests, SearchForDefinitionInCurrentScope) {
   ScopeResolver scope_resolver(Signature(""), nullptr);

   /**
    * signature[0] => {
    *   vnames[1],  ==> signature[1]
    *   vnames[2],  ==> signature[2]
    * }
    */

   Scope scope(signatures[0]);
   scope.AddMemberItem(vnames[1]);
   scope.AddMemberItem(vnames[2]);

   {
     ScopeContext::AutoPop p1(&scope_resolver.GetMutableScopeContext(), &scope);
     {
       const VName* vname =
           scope_resolver.SearchForDefinitionInCurrentScope(names[1]);
       EXPECT_EQ(vname->signature, signatures[1]);
     }
     {
       const VName* vname =
           scope_resolver.SearchForDefinitionInCurrentScope(names[2]);
       EXPECT_EQ(vname->signature, signatures[2]);
     }
     {
       const VName* vname =
           scope_resolver.SearchForDefinitionInCurrentScope(names[3]);
       EXPECT_EQ(vname, nullptr);
     }
     {
       const VName* vname =
           scope_resolver.SearchForDefinitionInCurrentScope(names[4]);
       EXPECT_EQ(vname, nullptr);
     }
   }
 }

 TEST(ScopeResolverTests, DeleteDefinitionFromCurrentScope) {
   ScopeResolver scope_resolver(Signature(""), nullptr);

   /**
    * signature[0] => {
    *   vnames[1],  ==> signature[1]
    *   vnames[2],  ==> signature[2]
    * }
    */

   Scope scope(signatures[0]);
   scope.AddMemberItem(vnames[1]);
   scope.AddMemberItem(vnames[2]);

   {
     ScopeContext::AutoPop p1(&scope_resolver.GetMutableScopeContext(), &scope);
     {
       const VName* vname =
           scope_resolver.SearchForDefinitionInCurrentScope(names[1]);
       EXPECT_EQ(vname->signature, signatures[1]);
     }

     {
       scope_resolver.RemoveDefinitionFromCurrentScope(vnames[1]);
       const VName* vname =
           scope_resolver.SearchForDefinitionInCurrentScope(names[1]);
       EXPECT_EQ(vname, nullptr);
     }
     {
       const VName* vname =
           scope_resolver.SearchForDefinitionInCurrentScope(names[2]);
       EXPECT_EQ(vname->signature, signatures[2]);
     }
   }
 }

 TEST(ScopeResolverTests, SearchForNestedDefinition) {
   ScopeResolver scope_resolver(Signature(""), nullptr);

   /**
    * signature[0] => {
    *   vnames[1],  ==> signature[1]
    *   vnames[2],  ==> signature[2]
    * }
    *
    * signature[1] => {
    *   vnames[3],  ==> signature[3];
    *   vnames[4],  ==> signature[4];
    * }
    *
    */

   Scope scope(signatures[0]);
   scope.AddMemberItem(vnames[1]);
   scope.AddMemberItem(vnames[2]);

   Scope scope2(signatures[1]);
   scope2.AddMemberItem(vnames[3]);
   scope2.AddMemberItem(vnames[4]);

   {
     Scope global_scope(signatures[7]);
     ScopeContext::AutoPop p1(&scope_resolver.GetMutableScopeContext(),
                              &global_scope);
     scope_resolver.AddDefinitionToCurrentScope(vnames[0]);
     scope_resolver.AddDefinitionToCurrentScope(vnames[1]);
     scope_resolver.AddDefinitionToCurrentScope(vnames[5]);
     scope_resolver.MapSignatureToScope(signatures[0], scope);
     scope_resolver.MapSignatureToScope(signatures[1], scope2);
     {
       const Scope* found_scope = scope_resolver.SearchForScope(signatures[0]);
       EXPECT_NE(found_scope, nullptr);
     }
     {
       const Scope* found_scope = scope_resolver.SearchForScope(signatures[1]);
       EXPECT_NE(found_scope, nullptr);
     }
     {
       const Scope* found_scope = scope_resolver.SearchForScope(signatures[6]);
       EXPECT_EQ(found_scope, nullptr);
     }
     {
       const std::vector<std::pair<const VName*, const Scope*>> vnames =
           scope_resolver.SearchForDefinitions({names[0], names[1]});
       EXPECT_EQ(vnames[1].first->signature, signatures[1]);
     }
     {
       const std::vector<std::pair<const VName*, const Scope*>> vnames =
           scope_resolver.SearchForDefinitions({names[1], names[3]});
       EXPECT_EQ(vnames[1].first->signature, signatures[3]);
     }
   }
 }

 TEST(VerticalScopeTests, SearchForDefinition) {
   ScopeContext vertical_scope_resolver;

   EXPECT_TRUE(vertical_scope_resolver.empty());
   {
     Scope scope;
     ScopeContext::AutoPop p1(&vertical_scope_resolver, &scope);
     vertical_scope_resolver.top().AddMemberItem(vnames[0]);
     EXPECT_EQ(vertical_scope_resolver.top().GetSignature(), Signature(""));
     EXPECT_EQ(vertical_scope_resolver.top().Members().size(), 1);
     {
       const VName* vname =
           vertical_scope_resolver.SearchForDefinition(names[0]);
       EXPECT_EQ(vname->signature, vnames[0].signature);
     }
     {
       const VName* vname =
           vertical_scope_resolver.SearchForDefinition(names[1]);
       EXPECT_EQ(vname, nullptr);
     }

     vertical_scope_resolver.top().AddMemberItem(vnames[1]);
     EXPECT_EQ(vertical_scope_resolver.top().Members().size(), 2);

     {
       const VName* vname =
           vertical_scope_resolver.SearchForDefinition(names[1]);
       EXPECT_EQ(vname->signature, signatures[1]);
     }
   }
   EXPECT_TRUE(vertical_scope_resolver.empty());
 }

 TEST(ScopeResolverTests, NestedScopeSearch) {
   ScopeContext scope_resolver;

   EXPECT_TRUE(scope_resolver.empty());
   Scope scope;
   ScopeContext::AutoPop p1(&scope_resolver, &scope);
   {
     scope_resolver.top().AddMemberItem(vnames[0]);
     EXPECT_EQ(scope_resolver.top().GetSignature(), Signature(""));
     EXPECT_EQ(scope_resolver.top().Members().size(), 1);

     const VName* vname = scope_resolver.SearchForDefinition(names[0]);
     EXPECT_EQ(vname->signature, vnames[0].signature);

     Scope scope(signatures[4]);
     ScopeContext::AutoPop p1(&scope_resolver, &scope);
     {
       scope_resolver.top().AddMemberItem(vnames[6]);
       EXPECT_EQ(scope_resolver.top().GetSignature(), signatures[4]);
       EXPECT_EQ(scope_resolver.top().Members().size(), 1);
       {
         const VName* vname = scope_resolver.SearchForDefinition(names[9]);
         EXPECT_EQ(vname->signature, vnames[6].signature);
       }
       {
         const VName* vname = scope_resolver.SearchForDefinition(names[8]);
         EXPECT_EQ(vname, nullptr);
       }
       {
         const VName* vname = scope_resolver.SearchForDefinition(names[0]);
         EXPECT_EQ(vname->signature, vnames[0].signature);
       }

       Scope scope(signatures[6]);
       ScopeContext::AutoPop p1(&scope_resolver, &scope);
       {
         scope_resolver.top().AddMemberItem(vnames[2]);
         EXPECT_EQ(scope_resolver.top().GetSignature(), signatures[6]);
         EXPECT_EQ(scope_resolver.top().Members().size(), 1);
         {
           const VName* vname = scope_resolver.SearchForDefinition(names[2]);
           EXPECT_EQ(vname->signature, vnames[2].signature);
         }
         {
           const VName* vname = scope_resolver.SearchForDefinition(names[9]);
           EXPECT_EQ(vname->signature, vnames[6].signature);
         }
         {
           const VName* vname = scope_resolver.SearchForDefinition(names[8]);
           EXPECT_EQ(vname, nullptr);
         }
         {
           const VName* vname = scope_resolver.SearchForDefinition(names[0]);
           EXPECT_EQ(vname->signature, vnames[0].signature);
         }
       }
     }
     EXPECT_EQ(scope_resolver.size(), 2);
   }
   EXPECT_EQ(scope_resolver.size(), 1);
 }

 }  // namespace
 }  // namespace kythe
 }  // namespace verilog
	// 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/tools/kythe/scope_resolver.h"

	#include <vector>

	#include "gtest/gtest.h"
	#include "verilog/tools/kythe/kythe_facts.h"

	namespace verilog {
	namespace kythe {
	namespace {

	constexpr absl::string_view names[] = {
	"signature0", "signature1", "signature2", "signature3",
	"signature4", "signature5", "signature6", "signature7",
	"signature8", "signature9", "",
	};

	static const std::vector<Signature> signatures{
	Signature(names[0]),
	Signature(names[1]),
	Signature(names[2]),
	Signature(names[3]),
	Signature(names[4]),
	Signature(Signature(names[5]), names[6]),
	Signature(Signature(Signature(names[7]), names[8]), names[9]),
	Signature(names[10]),
	};

	static const std::vector<VName> vnames{
	{.path = "", .root = "", .signature = signatures[0], .corpus = ""},
	{.path = "", .root = "", .signature = signatures[1], .corpus = ""},
	{.path = "", .root = "", .signature = signatures[2], .corpus = ""},
	{.path = "", .root = "", .signature = signatures[3], .corpus = ""},
	{.path = "", .root = "", .signature = signatures[4], .corpus = ""},
	{.path = "", .root = "", .signature = signatures[5], .corpus = ""},
	{.path = "", .root = "", .signature = signatures[6], .corpus = ""},
	{.path = "", .root = "", .signature = signatures[7], .corpus = ""},
	};

	TEST(ScopeResolverTests, ScopeResolverLinkedList) {
	/**
	* signature[0] => {
	* vnames[1], ==> signature[1]
	* vnames[2], ==> signature[2]
	* }
	*/

	Scope scope(signatures[0]);
	scope.AddMemberItem(vnames[1]);
	scope.AddMemberItem(vnames[2]);

	ScopeResolver scope_resolver1(Signature("file1"), nullptr);
	scope_resolver1.MapSignatureToScope(signatures[0], scope);

	ScopeResolver scope_resolver(Signature("file2"), &scope_resolver1);
	{
	Scope global_scope(signatures[7]);
	ScopeContext::AutoPop p1(&scope_resolver.GetMutableScopeContext(),
	&global_scope);
	scope_resolver.AddDefinitionToCurrentScope(vnames[0]);
	{
	const std::vector<std::pair<const VName, const Scope>> vnames =
	scope_resolver.SearchForDefinitions({names[0], names[1]});
	EXPECT_EQ(vnames.size(), 2);
	EXPECT_EQ(vnames[1].first->signature, signatures[1]);
	}
	{
	const std::vector<std::pair<const VName, const Scope>> vnames =
	scope_resolver.SearchForDefinitions({names[0], names[2]});
	EXPECT_EQ(vnames.size(), 2);
	EXPECT_EQ(vnames[1].first->signature, signatures[2]);
	}
	{
	const std::vector<std::pair<const VName, const Scope>> vnames =
	scope_resolver.SearchForDefinitions({names[0], names[3]});
	EXPECT_EQ(vnames.size(), 1);
	EXPECT_EQ(vnames[0].first->signature, signatures[0]);
	}
	{
	const std::vector<std::pair<const VName, const Scope>> vnames =
	scope_resolver.SearchForDefinitions({names[2], names[1]});
	EXPECT_TRUE(vnames.empty());
	}
	}
	}

	TEST(ScopesTest, AppendScope) {
	/**
	* signature[0] => {
	* vnames[1], ==> signature[1]
	* vnames[2], ==> signature[2]
	* }
	*
	* signature[1] => {
	* vnames[3], ==> signature[3];
	* vnames[4], ==> signature[4];
	* }
	*/

	Scope scope(signatures[0]);
	scope.AddMemberItem(vnames[1]);
	scope.AddMemberItem(vnames[2]);

	Scope scope2(signatures[1]);
	scope2.AddMemberItem(vnames[3]);
	scope2.AddMemberItem(vnames[4]);

	scope2.AppendScope(scope);

	{
	const VName* vname = scope2.SearchForDefinition(names[1]);
	EXPECT_EQ(vname->signature, signatures[1]);
	}
	{
	const VName* vname = scope2.SearchForDefinition(names[2]);
	EXPECT_EQ(vname->signature, signatures[2]);
	}
	{
	const VName* vname = scope2.SearchForDefinition(names[3]);
	EXPECT_EQ(vname->signature, signatures[3]);
	}
	{
	const VName* vname = scope2.SearchForDefinition(names[4]);
	EXPECT_EQ(vname->signature, signatures[4]);
	}
	}

	TEST(ScopesTest, RemoveMember) {
	/**
	* signature[0] => {
	* vnames[1], ==> signature[1]
	* vnames[2], ==> signature[2]
	* }
	*
	* signature[1] => {
	* vnames[3], ==> signature[3];
	* vnames[4], ==> signature[4];
	* }
	*/

	Scope scope(signatures[0]);
	scope.AddMemberItem(vnames[1]);
	scope.AddMemberItem(vnames[2]);

	{
	const VName* vname = scope.SearchForDefinition(names[1]);
	EXPECT_EQ(vname->signature, signatures[1]);
	}

	{
	scope.RemoveMember(vnames[1]);
	const VName* vname = scope.SearchForDefinition(names[1]);
	EXPECT_EQ(vname, nullptr);
	}

	{
	const VName* vname = scope.SearchForDefinition(names[2]);
	EXPECT_EQ(vname->signature, signatures[2]);
	}
	}

	TEST(ScopeResolverTests, SearchForDefinition) {
	ScopeResolver scope_resolver(Signature(""), nullptr);

	/**
	* signature[0] => {
	* vnames[1], ==> signature[1]
	* vnames[2], ==> signature[2]
	* }
	*/

	Scope scope(signatures[0]);
	scope.AddMemberItem(vnames[1]);
	scope.AddMemberItem(vnames[2]);

	{
	Scope global_scope(signatures[7]);
	ScopeContext::AutoPop p1(&scope_resolver.GetMutableScopeContext(),
	&global_scope);
	scope_resolver.AddDefinitionToCurrentScope(vnames[0]);
	scope_resolver.MapSignatureToScope(signatures[0], scope);
	{
	const std::vector<std::pair<const VName, const Scope>> vnames =
	scope_resolver.SearchForDefinitions({names[0], names[1]});
	EXPECT_EQ(vnames.size(), 2);
	EXPECT_EQ(vnames[1].first->signature, signatures[1]);
	}
	{
	const std::vector<std::pair<const VName, const Scope>> vnames =
	scope_resolver.SearchForDefinitions({names[0], names[2]});
	EXPECT_EQ(vnames.size(), 2);
	EXPECT_EQ(vnames[1].first->signature, signatures[2]);
	}
	{
	const std::vector<std::pair<const VName, const Scope>> vnames =
	scope_resolver.SearchForDefinitions({names[0], names[3]});
	EXPECT_EQ(vnames.size(), 1);
	EXPECT_EQ(vnames[0].first->signature, signatures[0]);
	}
	{
	const std::vector<std::pair<const VName, const Scope>> vnames =
	scope_resolver.SearchForDefinitions({names[2], names[1]});
	EXPECT_TRUE(vnames.empty());
	}
	}
	}

	TEST(ScopeResolverTests, SearchForDefinitionInCurrentScope) {
	ScopeResolver scope_resolver(Signature(""), nullptr);

	/**
	* signature[0] => {
	* vnames[1], ==> signature[1]
	* vnames[2], ==> signature[2]
	* }
	*/

	Scope scope(signatures[0]);
	scope.AddMemberItem(vnames[1]);
	scope.AddMemberItem(vnames[2]);

	{
	ScopeContext::AutoPop p1(&scope_resolver.GetMutableScopeContext(), &scope);
	{
	const VName* vname =
	scope_resolver.SearchForDefinitionInCurrentScope(names[1]);
	EXPECT_EQ(vname->signature, signatures[1]);
	}
	{
	const VName* vname =
	scope_resolver.SearchForDefinitionInCurrentScope(names[2]);
	EXPECT_EQ(vname->signature, signatures[2]);
	}
	{
	const VName* vname =
	scope_resolver.SearchForDefinitionInCurrentScope(names[3]);
	EXPECT_EQ(vname, nullptr);
	}
	{
	const VName* vname =
	scope_resolver.SearchForDefinitionInCurrentScope(names[4]);
	EXPECT_EQ(vname, nullptr);
	}
	}
	}

	TEST(ScopeResolverTests, DeleteDefinitionFromCurrentScope) {
	ScopeResolver scope_resolver(Signature(""), nullptr);

	/**
	* signature[0] => {
	* vnames[1], ==> signature[1]
	* vnames[2], ==> signature[2]
	* }
	*/

	Scope scope(signatures[0]);
	scope.AddMemberItem(vnames[1]);
	scope.AddMemberItem(vnames[2]);

	{
	ScopeContext::AutoPop p1(&scope_resolver.GetMutableScopeContext(), &scope);
	{
	const VName* vname =
	scope_resolver.SearchForDefinitionInCurrentScope(names[1]);
	EXPECT_EQ(vname->signature, signatures[1]);
	}

	{
	scope_resolver.RemoveDefinitionFromCurrentScope(vnames[1]);
	const VName* vname =
	scope_resolver.SearchForDefinitionInCurrentScope(names[1]);
	EXPECT_EQ(vname, nullptr);
	}
	{
	const VName* vname =
	scope_resolver.SearchForDefinitionInCurrentScope(names[2]);
	EXPECT_EQ(vname->signature, signatures[2]);
	}
	}
	}

	TEST(ScopeResolverTests, SearchForNestedDefinition) {
	ScopeResolver scope_resolver(Signature(""), nullptr);

	/**
	* signature[0] => {
	* vnames[1], ==> signature[1]
	* vnames[2], ==> signature[2]
	* }
	*
	* signature[1] => {
	* vnames[3], ==> signature[3];
	* vnames[4], ==> signature[4];
	* }
	*
	*/

	Scope scope(signatures[0]);
	scope.AddMemberItem(vnames[1]);
	scope.AddMemberItem(vnames[2]);

	Scope scope2(signatures[1]);
	scope2.AddMemberItem(vnames[3]);
	scope2.AddMemberItem(vnames[4]);

	{
	Scope global_scope(signatures[7]);
	ScopeContext::AutoPop p1(&scope_resolver.GetMutableScopeContext(),
	&global_scope);
	scope_resolver.AddDefinitionToCurrentScope(vnames[0]);
	scope_resolver.AddDefinitionToCurrentScope(vnames[1]);
	scope_resolver.AddDefinitionToCurrentScope(vnames[5]);
	scope_resolver.MapSignatureToScope(signatures[0], scope);
	scope_resolver.MapSignatureToScope(signatures[1], scope2);
	{
	const Scope* found_scope = scope_resolver.SearchForScope(signatures[0]);
	EXPECT_NE(found_scope, nullptr);
	}
	{
	const Scope* found_scope = scope_resolver.SearchForScope(signatures[1]);
	EXPECT_NE(found_scope, nullptr);
	}
	{
	const Scope* found_scope = scope_resolver.SearchForScope(signatures[6]);
	EXPECT_EQ(found_scope, nullptr);
	}
	{
	const std::vector<std::pair<const VName, const Scope>> vnames =
	scope_resolver.SearchForDefinitions({names[0], names[1]});
	EXPECT_EQ(vnames[1].first->signature, signatures[1]);
	}
	{
	const std::vector<std::pair<const VName, const Scope>> vnames =
	scope_resolver.SearchForDefinitions({names[1], names[3]});
	EXPECT_EQ(vnames[1].first->signature, signatures[3]);
	}
	}
	}

	TEST(VerticalScopeTests, SearchForDefinition) {
	ScopeContext vertical_scope_resolver;

	EXPECT_TRUE(vertical_scope_resolver.empty());
	{
	Scope scope;
	ScopeContext::AutoPop p1(&vertical_scope_resolver, &scope);
	vertical_scope_resolver.top().AddMemberItem(vnames[0]);
	EXPECT_EQ(vertical_scope_resolver.top().GetSignature(), Signature(""));
	EXPECT_EQ(vertical_scope_resolver.top().Members().size(), 1);
	{
	const VName* vname =
	vertical_scope_resolver.SearchForDefinition(names[0]);
	EXPECT_EQ(vname->signature, vnames[0].signature);
	}
	{
	const VName* vname =
	vertical_scope_resolver.SearchForDefinition(names[1]);
	EXPECT_EQ(vname, nullptr);
	}

	vertical_scope_resolver.top().AddMemberItem(vnames[1]);
	EXPECT_EQ(vertical_scope_resolver.top().Members().size(), 2);

	{
	const VName* vname =
	vertical_scope_resolver.SearchForDefinition(names[1]);
	EXPECT_EQ(vname->signature, signatures[1]);
	}
	}
	EXPECT_TRUE(vertical_scope_resolver.empty());
	}

	TEST(ScopeResolverTests, NestedScopeSearch) {
	ScopeContext scope_resolver;

	EXPECT_TRUE(scope_resolver.empty());
	Scope scope;
	ScopeContext::AutoPop p1(&scope_resolver, &scope);
	{
	scope_resolver.top().AddMemberItem(vnames[0]);
	EXPECT_EQ(scope_resolver.top().GetSignature(), Signature(""));
	EXPECT_EQ(scope_resolver.top().Members().size(), 1);

	const VName* vname = scope_resolver.SearchForDefinition(names[0]);
	EXPECT_EQ(vname->signature, vnames[0].signature);

	Scope scope(signatures[4]);
	ScopeContext::AutoPop p1(&scope_resolver, &scope);
	{
	scope_resolver.top().AddMemberItem(vnames[6]);
	EXPECT_EQ(scope_resolver.top().GetSignature(), signatures[4]);
	EXPECT_EQ(scope_resolver.top().Members().size(), 1);
	{
	const VName* vname = scope_resolver.SearchForDefinition(names[9]);
	EXPECT_EQ(vname->signature, vnames[6].signature);
	}
	{
	const VName* vname = scope_resolver.SearchForDefinition(names[8]);
	EXPECT_EQ(vname, nullptr);
	}
	{
	const VName* vname = scope_resolver.SearchForDefinition(names[0]);
	EXPECT_EQ(vname->signature, vnames[0].signature);
	}

	Scope scope(signatures[6]);
	ScopeContext::AutoPop p1(&scope_resolver, &scope);
	{
	scope_resolver.top().AddMemberItem(vnames[2]);
	EXPECT_EQ(scope_resolver.top().GetSignature(), signatures[6]);
	EXPECT_EQ(scope_resolver.top().Members().size(), 1);
	{
	const VName* vname = scope_resolver.SearchForDefinition(names[2]);
	EXPECT_EQ(vname->signature, vnames[2].signature);
	}
	{
	const VName* vname = scope_resolver.SearchForDefinition(names[9]);
	EXPECT_EQ(vname->signature, vnames[6].signature);
	}
	{
	const VName* vname = scope_resolver.SearchForDefinition(names[8]);
	EXPECT_EQ(vname, nullptr);
	}
	{
	const VName* vname = scope_resolver.SearchForDefinition(names[0]);
	EXPECT_EQ(vname->signature, vnames[0].signature);
	}
	}
	}
	EXPECT_EQ(scope_resolver.size(), 2);
	}
	EXPECT_EQ(scope_resolver.size(), 1);
	}

	} // namespace
	} // namespace kythe
	} // namespace verilog