Ejemplo n.º 1
0
        /// <inheritdoc />
        protected override object RunIsolatedTaskInHost <TIsolatedTask>(HostSetup hostSetup, StatusReporter statusReporter, object[] args)
        {
            NCoverTool tool = NCoverTool.GetInstance(version, hostSetup.ProcessorArchitecture);

            if (!tool.IsInstalled())
            {
                throw new TestIsolationException(string.Format("{0} does not appear to be installed.", tool.Name));
            }

            string ncoverArguments, ncoverCoverageFile;

            NCoverHost.GetNCoverProperties(hostSetup, out ncoverArguments, out ncoverCoverageFile);

            if (File.Exists(ncoverCoverageFile))
            {
                File.Delete(ncoverCoverageFile);
            }

            if (batch != null)
            {
                hostSetup = hostSetup.Copy();

                string tempCoverageFile = batch.Enlist(ncoverCoverageFile);
                NCoverHost.SetNCoverCoverageFile(hostSetup, tempCoverageFile);
            }

            return(base.RunIsolatedTaskInHost <TIsolatedTask>(hostSetup, statusReporter, args));
        }
Ejemplo n.º 2
0
        private static HostSetup ForceProcessorArchitectureAndRuntimeVersionIfRequired(HostSetup hostSetup, NCoverVersion version)
        {
            hostSetup = hostSetup.Copy();

            NCoverTool tool = NCoverTool.GetInstance(version, hostSetup.ProcessorArchitecture);

            hostSetup.ProcessorArchitecture = tool.NegotiateProcessorArchitecture(hostSetup.ProcessorArchitecture);
            hostSetup.RuntimeVersion        = tool.NegotiateRuntimeVersion(hostSetup.RuntimeVersion);

            return(hostSetup);
        }
Ejemplo n.º 3
0
        /// <inheritdoc />
        protected override ProcessTask CreateProcessTask(string executablePath, string arguments, string workingDirectory)
        {
            string ncoverArguments, ncoverCoverageFile;

            GetNCoverProperties(HostSetup, out ncoverArguments, out ncoverCoverageFile);

            NCoverTool tool = NCoverTool.GetInstance(version, HostSetup.ProcessorArchitecture);

            return(tool.CreateNCoverConsoleTask(executablePath, arguments, workingDirectory,
                                                ncoverArguments, ncoverCoverageFile, Logger));
        }
Ejemplo n.º 4
0
            private void Merge(IList <string> sources, string destination)
            {
                NCoverTool tool = NCoverTool.GetInstance(version, ProcessorArchitecture.None);

                tool.Merge(sources, destination, logger);
            }
        public void GeneratesNCoverCoverageWithCorrectOptionsAndMergesIfNecessary(string factoryName, NCoverVersion version,
                                                                                  string ncoverCoverageFile, bool includeLogArgument, bool runMultipleAssemblies)
        {
            string tempPath            = SpecialPathPolicy.For <NCoverTestIsolationProviderIntegrationTest>().GetTempDirectory().FullName;
            string coverageFilePath    = Path.Combine(tempPath, ncoverCoverageFile ?? "Coverage.xml");
            string coverageLogFilePath = Path.Combine(tempPath, "CoverageLog.txt");

            string ncoverArguments = includeLogArgument
                ? "//l \"" + coverageLogFilePath + "\"" + (version == NCoverVersion.V1 ? "" : " //ll Normal")
                : null;

            if (File.Exists(coverageFilePath))
            {
                File.Delete(coverageFilePath);
            }

            if (File.Exists(coverageLogFilePath))
            {
                File.Delete(coverageLogFilePath);
            }

            Type firstTestType  = typeof(SimpleTest);
            Type secondTestType = typeof(DummyTest);

            TestLauncher launcher = new TestLauncher();

            launcher.Logger = new MarkupStreamLogger(TestLog.Default);

            launcher.TestProject.TestPackage.AddFile(new FileInfo(AssemblyUtils.GetAssemblyLocalPath(firstTestType.Assembly)));
            if (runMultipleAssemblies)
            {
                launcher.TestProject.TestPackage.AddFile(new FileInfo(AssemblyUtils.GetAssemblyLocalPath(secondTestType.Assembly)));
            }

            launcher.TestProject.TestRunnerFactoryName = factoryName;
            launcher.TestExecutionOptions.FilterSet    = new FilterSet <ITestDescriptor>(
                new OrFilter <ITestDescriptor>(new[]
            {
                new TypeFilter <ITestDescriptor>(new EqualityFilter <string>(firstTestType.FullName), false),
                new TypeFilter <ITestDescriptor>(new EqualityFilter <string>(secondTestType.FullName), false),
            }));

            if (ncoverArguments != null)
            {
                launcher.TestRunnerOptions.AddProperty("NCoverArguments", ncoverArguments);
            }
            if (ncoverCoverageFile != null)
            {
                launcher.TestRunnerOptions.AddProperty("NCoverCoverageFile", ncoverCoverageFile);
            }

            TestLauncherResult result;

            using (new CurrentDirectorySwitcher(tempPath))
                result = launcher.Run();

            NCoverTool tool = NCoverTool.GetInstance(version, ProcessorArchitecture.MSIL);

            if (!tool.IsInstalled())
            {
                Assert.AreEqual(ResultCode.Failure, result.ResultCode);

                var logEntries = result.Report.LogEntries;
                Assert.AreEqual(1, logEntries.Count, "Expected to find a log entry.");
                Assert.AreEqual(LogSeverity.Error, logEntries[0].Severity);
                Assert.Contains(logEntries[0].Details, tool.Name + " does not appear to be installed.");
            }
            else
            {
                int passed = runMultipleAssemblies ? 2 : 1;
                int failed = 1;

                Assert.AreEqual(passed + failed, result.Statistics.RunCount);
                Assert.AreEqual(passed, result.Statistics.PassedCount);
                Assert.AreEqual(failed, result.Statistics.FailedCount);
                Assert.AreEqual(0, result.Statistics.InconclusiveCount);
                Assert.AreEqual(0, result.Statistics.SkippedCount);

                Assert.IsTrue(File.Exists(coverageFilePath),
                              "The NCover runner should have written its coverage log to '{0}'.", coverageFilePath);

                string coverageXml = File.ReadAllText(coverageFilePath);
                File.Delete(coverageFilePath);

                Assert.Contains(coverageXml, firstTestType.Name,
                                "Expected the coverage log to include information about the test method that we actually ran.\n"
                                + "In NCover v3, there is now a list of excluded 'system assemblies' in NCover.Console.exe.config which "
                                + "specifies MbUnit and Gallio by default.  For this test to run, the file must be edited such that "
                                + "these entries are removed.");

                if (runMultipleAssemblies)
                {
                    Assert.Contains(coverageXml, secondTestType.Name,
                                    "Expected the coverage log to include information about the test method that we actually ran.\n"
                                    + "In NCover v3, there is now a list of excluded 'system assemblies' in NCover.Console.exe.config which "
                                    + "specifies MbUnit and Gallio by default.  For this test to run, the file must be edited such that "
                                    + "these entries are removed.");
                }

                if (ncoverArguments != null && ncoverArguments.Contains("/l"))
                {
                    Assert.IsTrue(File.Exists(coverageLogFilePath),
                                  "Should have created a coverage log file since the /l argument was specified.");
                    File.Delete(coverageLogFilePath);
                }
            }
        }