public GlobalProjectProperties(ProjectNode project)
		{
			msBuildProject = project.As<Project>();
			dteProject = project.As<EnvDTE.Project>();
			vsBuild = project.HierarchyNode.HierarchyIdentity.Hierarchy as IVsBuildPropertyStorage;
			accessor = new DynamicPropertyAccessor(this);
		}

		public void TestAcceptsProjectReferenceToItSelf()
		{
			ProjectNode projectNode = new ProjectNode(vsSolution, project.GUID);
			int before = project.Children.Count;
			projectNode.AddProjectReference(project.GUID);
			Assert.AreEqual<int>(before,project.Children.Count);
		}

		public TreeNode AddProjectNode(ExtTreeView classBrowser, IProject project)
		{
			ProjectNode prjNode = new ProjectNode(project);
			prjNode.AddTo(classBrowser);
			classBrowser.Sort();
			return prjNode;
		}

        public void SelectParentWillSelectAllChildrenExceptTheDisabledOnes()
        {
            // Arrange
            ProjectNode[] children = new ProjectNode[3];

            // make two children enabled, one disabled
            for (int i = 0; i < 3; i++)
            {
                var project = MockProjectUtility.CreateMockProject("p" + i);
                var node = new ProjectNode(project)
                {
                    IsEnabled = i % 2 == 0
                };
                children[i] = node;
            }

            var folder = new FolderNode(null, "A", children);

            // Act
            folder.IsSelected = true;

            // Assert
            Assert.True(children[0].IsSelected == true);
            Assert.True(children[1].IsSelected == false);
            Assert.True(children[2].IsSelected == true);
        }

		public void AddItemWithEmptyNameThrows()
		{
			ProjectNode projectNode = new ProjectNode(vsSolution, project.GUID);
			string itemName = ".cs";
			string fullItemName = new FileInfo(itemName).FullName;
			projectNode.AddItem(itemName);
		}

		public void TestCanAddItem()
		{
			ProjectNode projectNode = new ProjectNode(vsSolution, project.GUID);
			string itemName = "item1.cs";
			Assert.IsTrue(projectNode.CanAddItem(itemName));
			string invalidItemName = "<item1>.cs";
			Assert.IsFalse(projectNode.CanAddItem(invalidItemName));
		}

		public void TestAddItem()
		{
			ProjectNode projectNode = new ProjectNode(vsSolution, project.GUID);
			string itemName = "item1.cs";
			projectNode.AddItem(itemName);
			string fullItemName = new FileInfo(itemName).FullName;
			Assert.IsTrue(project.Children.Contains(fullItemName));
		}

 public IEnumerable<IDependencyNode> GetReferencesNeedCopy(ProjectNode dest)
 {
     var projectSources = dest.ProjectReferences.Where(r => r.CopyLocal)
         .Select(r => (IDependencyNode)r.Node);
     var assemblySources = dest.AssemblyReferences.Where(r => r.CopyLocal)
         .Select(LoadAssembly);
     return projectSources.Concat(assemblySources);
 }

        public OAProject(ProjectNode project)
        {
            this.project = project;

            if (project is ProjectContainerNode)
            {
                this.solutionFolder = new Microsoft.VisualStudio.Package.Automation.OASolutionFolder<ProjectContainerNode>((ProjectContainerNode)project);
            }
        }

        public void ProjectPropertyIsCorrect()
        {
            // Arrange
            var project = MockProjectUtility.CreateMockProject("A");
            var node = new ProjectNode(project);

            // Act & Assert
            Assert.Same(project, node.Project);
        }

        public void IsSelectedFalseByDefault()
        {
            // Arrange
            var project = MockProjectUtility.CreateMockProject("A");
            var node = new ProjectNode(project);

            // Act & Assert
            Assert.True(node.IsSelected == false);
        }

        public void NamePropertyIsCorrect()
        {
            // Arrange
            var project = MockProjectUtility.CreateMockProject("A");
            var node = new ProjectNode(project);

            // Act & Assert
            Assert.Equal("A", node.Name);
        }

 private static CopyLocalSet CreateCopyLocalSet(ProjectNode p, ResolveContext context)
 {
     return new CopyLocalSet
     {
         Dest = p,
         ProjectCopySource = context.GetProjectReferencesNeedCopy(p).ToArray(),
         AssemblyCopySource = context.GetAssemblyReferencesNeedCopy(p).ToArray(),
         RuntimeCopySources = context.GetRuntimeReferencesNeedCopy(p).ToArray()
     };
 }

		public ConfigProjectProperties(ProjectNode project, string configName)
		{
			this.project = project;
			this.configName = configName;
			vsBuild = project.HierarchyNode.HierarchyIdentity.Hierarchy as IVsBuildPropertyStorage;
			if (vsBuild == null)
				tracer.Warn(Strings.ConfigProjectProperties.NonMsBuildProject(project.Text));

			accessor = new DynamicPropertyAccessor(this);
		}

        public void GetSelectedProjectReturnsEmptyIfIsSelectedIsFalse()
        {
            // Arrange
            var project = MockProjectUtility.CreateMockProject("A");
            var node = new ProjectNode(project);

            // Act
            node.IsSelected = false;

            // Assert
            Assert.False(node.GetSelectedProjects().Any());
        }

		public UserProjectProperties(ProjectNode project)
		{
			this.project = project;
			msBuildProject = project.As<Project>();
			dteProject = project.As<EnvDTE.Project>();
			vsBuild = project.HierarchyNode.VsHierarchy as IVsBuildPropertyStorage;

			if (msBuildProject == null || vsBuild == null)
				tracer.Warn(Strings.UserProjectProperties.NonMsBuildProject(project.DisplayName));

			accessor = new DynamicPropertyAccessor(this);
		}

        public void GetSelectedProjectReturnsProjectIfIsSelectedIsTrueAndIsEnabledIsTrue()
        {
            // Arrange
            var project = MockProjectUtility.CreateMockProject("A");
            var node = new ProjectNode(project);

            // Act
            node.IsSelected = true;
            node.IsEnabled = true;

            // Assert
            Assert.Same(project, node.GetSelectedProjects().Single());
        }

 public ProjectNode BuildUp()
 {
     if (!cache.ContainsKey(projectFullPath))
     {
         var extractor = new ProjectExtractor(projectFullPath, resolveConfig);
         var project = new ProjectNode
                           {
                               Id = extractor.GetId(),
                               AssemblyReferences = GetAssemblyReferences(extractor),
                               ProjectReferences = GetProjectReferences(extractor),
                               RuntimeReferences = GetRuntimeReferences(extractor),
                               FullPath = projectFullPath,
                               Output = resolveConfig.GetAssemblyNameByProjectPath(projectFullPath)
                           };
         cache[projectFullPath] = project;
     }
     return cache[projectFullPath];
 }

        public static void AddProjectsToTree(Solution solution,ref Tree tree)
        {
            var projects = solution.Projects.ToList();
            var allreadyAddedProjects = tree.DescendantNodes().OfType<ProjectNode>().ToList();

            foreach (var project in projects)
            {
                var existingProject = allreadyAddedProjects.WithName(project.Name);
                if (existingProject != null)
                {
                    existingProject.Documents = project.Documents.ToList();
                }
                else
                {
                    existingProject = new ProjectNode(project);
                    tree.AddChild(existingProject);
                }
            }
        }

        public void GetSelectedProjectReturnsEmptyIfIsSelectedIsFalseOrIsEnabledIsFalse()
        {
            // Arrange
            var project = MockProjectUtility.CreateMockProject("A");
            var node = new ProjectNode(project);

            // Act
            node.IsSelected = false;
            node.IsEnabled = false;
            var result1 = node.GetSelectedProjects();

            node.IsSelected = true;
            node.IsEnabled = false;
            var result2 = node.GetSelectedProjects();

            node.IsSelected = false;
            node.IsEnabled = true;
            var result3 = node.GetSelectedProjects();

            // Assert
            Assert.False(result1.Any());
            Assert.False(result2.Any());
            Assert.False(result3.Any());
        }