public Task <int> Execute()
        {
            var assemblies = GetFiles(_includeAssembliesOption.Value, _excludeAssembliesOption.Value, _parentDirOption.DirectoryInfo);

            if (assemblies.Length == 0)
            {
                throw new ValidationException("No assemblies found");
            }

            var sourceFiles = GetFiles(_includeSourceOption.Value, _excludeSourceOption.Value, _parentDirOption.DirectoryInfo);

            if (sourceFiles.Length == 0)
            {
                throw new ValidationException("No source files found");
            }

            var testFiles = GetFiles(_includeTestsOption.Value, _excludeTestsOption.Value, _parentDirOption.DirectoryInfo);

            var instrumentationContext = new FileBasedInstrumentationContext
            {
                Assemblies = assemblies,
                HitsPath   = _hitsDirectoryOption.DirectoryInfo.FullName,
                Sources    = sourceFiles,
                Tests      = testFiles,
                Workdir    = _workingDirectoryOption.DirectoryInfo
            };

            var result = _instrumenter.Instrument(instrumentationContext);

            var coverageFile = _coverageFileOption.FileInfo;

            SaveCoverageFile(coverageFile, result);

            return(Task.FromResult(0));
        }
        public async Task HandleAsync(
            TestProvider provider,
            IDirectoryInfo settingsDirectory)
        {
            var workingDirectory = _fileSystem.GetWorkingDirectory();
            var assemblies       = GetFiles(
                new[]
            {
                ".pruner-bin/**/*.dll"
            },
                new[]
            {
                "**/obj/**/*.dll"
            },
                workingDirectory);

            if (assemblies.Length == 0)
            {
                throw new ValidationException($"No assemblies found from directory {workingDirectory.FullName}");
            }

            var sourceFiles = GetFiles(
                new[]
            {
                "**/*.cs"
            },
                new[]
            {
                "**/bin/**/*.cs",
                "**/obj/**/*.cs"
            },
                workingDirectory);

            if (sourceFiles.Length == 0)
            {
                throw new ValidationException($"No source files found from directory {workingDirectory.FullName}");
            }

            var testFiles = GetFiles(
                new[]
            {
                "tests/**/*.cs",
                "test/**/*.cs",
                "**/*.Tests/**/*.cs"
            },
                new[]
            {
                "**/bin/**/*.cs",
                "**/obj/**/*.cs"
            },
                workingDirectory);

            DebugFileCollection("Assemblies", assemblies);
            DebugFileCollection("Source files", sourceFiles);
            DebugFileCollection("Test files", testFiles);

            var instrumentationContext = new FileBasedInstrumentationContext
            {
                Assemblies = assemblies,
                HitsPath   = EnsureCleanHitsDirectoryPath(settingsDirectory),
                Sources    = sourceFiles,
                Tests      = testFiles,
                Workdir    = workingDirectory
            };

            var result = _instrumenter.Instrument(instrumentationContext);

            await SaveCoverageFileAsync(
                _fileSystem.FileInfo.FromFileName(
                    DirectoryUtilities.GetCoverageJsonFilePathFromSettingsDirectory(settingsDirectory)),
                result);
        }