lucaslorentz / minicover / #59

pending completion

Build # #59

Build Type

push

azure-devops

Committed by

web-flow

Commit Message

<a href="https://github.com/lucaslorentz/minicover/commit/<a class=hub.com/lucaslorentz/minicover/commit/c9e93936fd6d4b26c279fd75e62b2415214d9c42">c9e93936f<a href="https://github.com/lucaslorentz/minicover/commit/c9e93936fd6d4b26c279fd75e62b2415214d9c42">">Merge </a><a class="double-link" href="https://github.com/lucaslorentz/minicover/commit/<a class="double-link" href="https://github.com/lucaslorentz/minicover/commit/95ea66fbe57a37845261522fb332a235d9076adc">95ea66fbe</a>">95ea66fbe</a><a href="https://github.com/lucaslorentz/minicover/commit/c9e93936fd6d4b26c279fd75e62b2415214d9c42"> into b0076170c">b0076170c</a>

Run Details

69 of 69 new or added lines in 5 files covered. (100.0%)

524 of 2151 relevant lines covered (24.36%)

2423.65 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/MiniCover/Instrumentation/AssemblyInstrumenter.cs

﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using Microsoft.Extensions.Logging;
using MiniCover.Extensions;
using MiniCover.HitServices;
using MiniCover.Model;
using MiniCover.Utils;
using Mono.Cecil;

namespace MiniCover.Instrumentation
{
    public class AssemblyInstrumenter
    {
        private static readonly ConstructorInfo instrumentedAttributeConstructor = typeof(InstrumentedAttribute).GetConstructors().First();

        private readonly TypeInstrumenter _typeInstrumenter;
        private readonly ILogger<AssemblyInstrumenter> _logger;
        private readonly ILogger<CustomAssemblyResolver> _assemblyResolverLogger;

        public AssemblyInstrumenter(
            TypeInstrumenter typeInstrumenter,
            ILogger<AssemblyInstrumenter> logger,
            ILogger<CustomAssemblyResolver> assemblyResolverLogger)
        {
            _typeInstrumenter = typeInstrumenter;
            _logger = logger;
            _assemblyResolverLogger = assemblyResolverLogger;
        }

        public InstrumentedAssembly InstrumentAssemblyFile(
            InstrumentationContext context,
            FileInfo assemblyFile)
        {
            var assemblyDirectory = assemblyFile.Directory;

            var resolver = new CustomAssemblyResolver(assemblyDirectory, _assemblyResolverLogger);

            _logger.LogTrace("Assembly resolver search directories: {directories}", new object[] { resolver.GetSearchDirectories() });

            try
            {
                using (var assemblyDefinition = AssemblyDefinition.ReadAssembly(assemblyFile.FullName, new ReaderParameters { ReadSymbols = true, AssemblyResolver = resolver }))
                {
                    return InstrumentAssemblyDefinition(context, assemblyDefinition);
                }
            }
            catch (BadImageFormatException)
            {
                _logger.LogInformation("Invalid assembly format");
                return null;
            }
        }

        private InstrumentedAssembly InstrumentAssemblyDefinition(
            InstrumentationContext context,
            AssemblyDefinition assemblyDefinition)
        {
            if (assemblyDefinition.CustomAttributes.Any(a => a.AttributeType.Name == "InstrumentedAttribute"))
            {
                _logger.LogInformation("Already instrumented");
                return null;
            }

            var assemblyDocuments = assemblyDefinition.GetAllDocuments();

            if (!assemblyDocuments.Any(d => context.IsSource(d.Url) || context.IsTest(d.Url)))
            {
                _logger.LogInformation("No link to source files or test files");
                return null;
            }

            var changedDocuments = assemblyDocuments.Where(d => d.FileHasChanged()).ToArray();
            if (changedDocuments.Any())
            {
                if (_logger.IsEnabled(LogLevel.Debug))
                {
                    var changedFiles = changedDocuments.Select(d => d.Url).Distinct().ToArray();
                    _logger.LogDebug("Source files has changed: {changedFiles}", new object[] { changedFiles });
                }
                else
                {
                    _logger.LogInformation("Source files has changed");
                }
                return null;
            }

            _logger.LogInformation("Instrumenting");

            var instrumentedAssembly = new InstrumentedAssembly(assemblyDefinition.Name.Name);
            var instrumentedAttributeReference = assemblyDefinition.MainModule.ImportReference(instrumentedAttributeConstructor);
            assemblyDefinition.CustomAttributes.Add(new CustomAttribute(instrumentedAttributeReference));

            foreach (var type in assemblyDefinition.MainModule.GetTypes())
            {
                _typeInstrumenter.InstrumentType(
                    context,
                    type,
                    instrumentedAssembly);
            }

            var miniCoverTempPath = GetMiniCoverTempPath();

            var instrumentedAssemblyFile = new FileInfo(Path.Combine(miniCoverTempPath, $"{Guid.NewGuid()}.dll"));
            var instrumentedPdbFile = FileUtils.GetPdbFile(instrumentedAssemblyFile);

            assemblyDefinition.Write(instrumentedAssemblyFile.FullName, new WriterParameters { WriteSymbols = true });

            instrumentedAssembly.TempAssemblyFile = instrumentedAssemblyFile.FullName;
            instrumentedAssembly.TempPdbFile = instrumentedPdbFile.FullName;

            return instrumentedAssembly;
        }

        private static string GetMiniCoverTempPath()
        {
            var path = Path.Combine(Path.GetTempPath(), "minicover");
            if (!Directory.Exists(path))
                Directory.CreateDirectory(path);
            return path;
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.IO;
4	using System.Linq;
5	using System.Reflection;
6	using Microsoft.Extensions.Logging;
7	using MiniCover.Extensions;
8	using MiniCover.HitServices;
9	using MiniCover.Model;
10	using MiniCover.Utils;
11	using Mono.Cecil;
12
13	namespace MiniCover.Instrumentation
14	{
15	public class AssemblyInstrumenter
16	{
17	private static readonly ConstructorInfo instrumentedAttributeConstructor = typeof(InstrumentedAttribute).GetConstructors().First();	×
18
19	private readonly TypeInstrumenter _typeInstrumenter;
20	private readonly ILogger<AssemblyInstrumenter> _logger;
21	private readonly ILogger<CustomAssemblyResolver> _assemblyResolverLogger;
22
23	public AssemblyInstrumenter(	×
24	TypeInstrumenter typeInstrumenter,	×
25	ILogger<AssemblyInstrumenter> logger,	×
26	ILogger<CustomAssemblyResolver> assemblyResolverLogger)	×
27	{
28	_typeInstrumenter = typeInstrumenter;	×
29	_logger = logger;	×
30	_assemblyResolverLogger = assemblyResolverLogger;	×
31	}
32
33	public InstrumentedAssembly InstrumentAssemblyFile(
34	InstrumentationContext context,
35	FileInfo assemblyFile)
36	{
37	var assemblyDirectory = assemblyFile.Directory;	×
38
39	var resolver = new CustomAssemblyResolver(assemblyDirectory, _assemblyResolverLogger);	×
40
41	_logger.LogTrace("Assembly resolver search directories: {directories}", new object[] { resolver.GetSearchDirectories() });	×
42
43	try
44	{
45	using (var assemblyDefinition = AssemblyDefinition.ReadAssembly(assemblyFile.FullName, new ReaderParameters { ReadSymbols = true, AssemblyResolver = resolver }))	×
46	{
47	return InstrumentAssemblyDefinition(context, assemblyDefinition);	×
48	}
49	}
50	catch (BadImageFormatException)	×
51	{
52	_logger.LogInformation("Invalid assembly format");	×
53	return null;	×
54	}
55	}
56
57	private InstrumentedAssembly InstrumentAssemblyDefinition(
58	InstrumentationContext context,
59	AssemblyDefinition assemblyDefinition)
60	{
61	if (assemblyDefinition.CustomAttributes.Any(a => a.AttributeType.Name == "InstrumentedAttribute"))	×
62	{
63	_logger.LogInformation("Already instrumented");	×
64	return null;	×
65	}
66
67	var assemblyDocuments = assemblyDefinition.GetAllDocuments();	×
68
69	if (!assemblyDocuments.Any(d => context.IsSource(d.Url) \|\| context.IsTest(d.Url)))	×
70	{
71	_logger.LogInformation("No link to source files or test files");	×
72	return null;	×
73	}
74
75	var changedDocuments = assemblyDocuments.Where(d => d.FileHasChanged()).ToArray();	×
76	if (changedDocuments.Any())	×
77	{
78	if (_logger.IsEnabled(LogLevel.Debug))	×
79	{
80	var changedFiles = changedDocuments.Select(d => d.Url).Distinct().ToArray();	×
81	_logger.LogDebug("Source files has changed: {changedFiles}", new object[] { changedFiles });	×
82	}
83	else
84	{
85	_logger.LogInformation("Source files has changed");	×
86	}
87	return null;	×
88	}
89
90	_logger.LogInformation("Instrumenting");	×
91
92	var instrumentedAssembly = new InstrumentedAssembly(assemblyDefinition.Name.Name);	×
93	var instrumentedAttributeReference = assemblyDefinition.MainModule.ImportReference(instrumentedAttributeConstructor);	×
94	assemblyDefinition.CustomAttributes.Add(new CustomAttribute(instrumentedAttributeReference));	×
95
96	foreach (var type in assemblyDefinition.MainModule.GetTypes())	×
97	{
98	_typeInstrumenter.InstrumentType(	×
99	context,	×
100	type,	×
101	instrumentedAssembly);	×
102	}
103
104	var miniCoverTempPath = GetMiniCoverTempPath();	×
105
106	var instrumentedAssemblyFile = new FileInfo(Path.Combine(miniCoverTempPath, $"{Guid.NewGuid()}.dll"));	×
107	var instrumentedPdbFile = FileUtils.GetPdbFile(instrumentedAssemblyFile);	×
108
109	assemblyDefinition.Write(instrumentedAssemblyFile.FullName, new WriterParameters { WriteSymbols = true });	×
110
111	instrumentedAssembly.TempAssemblyFile = instrumentedAssemblyFile.FullName;	×
112	instrumentedAssembly.TempPdbFile = instrumentedPdbFile.FullName;	×
113
114	return instrumentedAssembly;	×
115	}
116
117	private static string GetMiniCoverTempPath()
118	{
119	var path = Path.Combine(Path.GetTempPath(), "minicover");	×
120	if (!Directory.Exists(path))	×
121	Directory.CreateDirectory(path);	×
122	return path;	×
123	}
124	}
125	}

lucaslorentz / minicover / #59

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous