public void Should_ExcludeFromCodeCoverage_If_Has_Project_Property_FCCExcludeFromCodeCoverage(bool addProperty)
        {
            var property = addProperty ? $"<{ReferencedProject.excludeFromCodeCoveragePropertyName}/>" : "";

            WriteProperty(property);
            var referencedProject = new ReferencedProject(tempProjectFilePath, "");

            Assert.AreEqual(addProperty, referencedProject.ExcludeFromCodeCoverage);
        }
Esempio n. 2
0
        public override async void Analyze(RepoProject project)
        {
            var logger = project.Repo.AnalysisServices.Logger;

            try
            {
                var services = project.Repo.AnalysisServices;
                logger.LogMessage("Loading project: " + project.ProjectId);

                using (services.TaskDispatcher.TrackScope())
                {
                    await services.TaskDispatcher.Invoke(async() =>
                    {
                        var solution = await lazySolution.Value;
                        Project      = solution.GetProject(ProjectId);
                        if (Project == null)
                        {
                            logger.LogError($"Can't find project for {ProjectId} in {solution}");
                        }
                        else
                        {
                            Compilation         = await Project.GetCompilationAsync();
                            CompilationServices = new CompilationServices(Compilation);

                            foreach (var reference in Compilation.ReferencedAssemblyNames)
                            {
                                var referencedProject = new ReferencedProject()
                                {
                                    ProjectId   = reference.Name,
                                    DisplayName = reference.GetDisplayName(),
                                    Properties  = new Dictionary <string, string>()
                                    {
                                        { "PublicKey", string.Concat(reference.PublicKey.Select(b => b.ToString("X2"))) }
                                    }
                                };

                                ProjectContext.ReferencedProjects.TryAdd(referencedProject.ProjectId, referencedProject);
                            }
                        }

                        base.Analyze(project);
                    });

                    var documents = await Task.WhenAll(DocumentAnalysisTasks);

                    ProjectContext.Finish(project);

                    UploadProject(project, ProjectContext.Project);

                    project.Analyzer = RepoProjectAnalyzer.Null;
                }
            }
            catch (Exception ex)
            {
                logger.LogExceptionError($"Loading project {project.ProjectId}", ex);
            }
        }
Esempio n. 3
0
 public override int GetHashCode()
 {
     unchecked
     {
         if (reference != null)
         {
             return(ReferencedProject.GetHashCode() ^ 19983);
         }
         else
         {
             return(0);
         }
     }
 }
Esempio n. 4
0
        private static List <ReferencedProject> GetReferencedProjects(CoverageProject project)
        {
            /*
             * <ItemGroup>
             *      <ProjectReference Include="..\BranchCoverage\Branch_Coverage.csproj" />
             *      <ProjectReference Include="..\FxClassLibrary1\FxClassLibrary1.csproj"></ProjectReference>
             * </ItemGroup>
             */

            var referencedProjects = new List <ReferencedProject>();

            var xprojectReferences = project.ProjectFileXElement.XPathSelectElements($"/ItemGroup/ProjectReference[@Include]");

            foreach (var xprojectReference in xprojectReferences)
            {
                var referencedProject = new ReferencedProject();

                // ProjectFile

                referencedProject.ProjectFile = xprojectReference.Attribute("Include").Value;

                if (!Path.IsPathRooted(referencedProject.ProjectFile))
                {
                    referencedProject.ProjectFile = Path.GetFullPath(Path.Combine(project.ProjectFolder, referencedProject.ProjectFile));
                }

                // ProjectFileXElement

                referencedProject.ProjectFileXElement = XElementUtil.Load(referencedProject.ProjectFile, true);

                // HasExcludeFromCodeCoverageAssemblyAttribute

                referencedProject.HasExcludeFromCodeCoverageAssemblyAttribute = HasExcludeFromCodeCoverageAssemblyAttribute(referencedProject.ProjectFileXElement);

                // AssemblyName

                referencedProject.AssemblyName = GetAssemblyName(referencedProject.ProjectFileXElement, Path.GetFileNameWithoutExtension(referencedProject.ProjectFile));

                // add

                referencedProjects.Add(referencedProject);
            }

            return(referencedProjects);
        }
        public void AssemblyName_Should_Be_The_Name_Of_The_Dll()
        {
            var referencedProject = new ReferencedProject("", @"C:\Users\tonyh\Source\Repos\RefProject\RefProject\bin\Debug\RefProject.dll");

            Assert.AreEqual("RefProject", referencedProject.AssemblyName);
        }