public void AppDomainUnloadedBug()
 {
     TestDomain domain = new TestDomain();
     domain.Load( new TestPackage( mockDll ) );
     domain.Run(new NullListener(), TestFilter.Empty, false, LoggingThreshold.Off);
     domain.Unload();
 }
 public void AppDomainUnloadedBug()
 {
     TestDomain domain = new TestDomain();
     domain.Load( new TestPackage( "mock-assembly.dll" ) );
     domain.Run(new NullListener());
     domain.Unload();
 }
Beispiel #3
0
 public void AppDomainUnloadedBug()
 {
     TestDomain domain = new TestDomain();
     domain.Load( new TestPackage( mockDll ) );
     domain.Run(new NullListener());
     domain.Unload();
 }
Beispiel #4
0
        private static bool MakeTestFromCommandLine(TestDomain testDomain,
                                                    string testDll)
        {
            ServiceManager.Services.AddService(new DomainManager());
            var package = new TestPackage(testDll);

            return(testDomain.Load(package));
        }
Beispiel #5
0
        private Test MakeTest(TestDomain testDomain, string assemblyName)
        {
            NUnitProject project;

            project = NUnitProject.FromAssembly(assemblyName);

            return(testDomain.Load(project));
        }
        public void AppDomainUnloadedBug()
        {
            TestDomain domain = new TestDomain();

            domain.Load(new TestPackage("mock-assembly.dll"));
            domain.Run(new NullListener());
            domain.Unload();
        }
Beispiel #7
0
        public void AppDomainUnloadedBug()
        {
            TestDomain domain = new TestDomain();

            domain.Load(new TestPackage(mockDll));
            domain.Run(new NullListener());
            domain.Unload();
        }
        public void MakeAppDomain()
        {
            TextWriter outStream   = new ConsoleWriter(Console.Out);
            TextWriter errorStream = new ConsoleWriter(Console.Error);

            domain = new TestDomain(outStream, errorStream);
            test   = domain.Load("mock-assembly.dll");
        }
        public void AppDomainUnloadedBug()
        {
            TestDomain domain = new TestDomain();

            domain.Load(new TestPackage(mockDll));
            domain.Run(new NullListener(), TestFilter.Empty, false, LoggingThreshold.Off);
            domain.Unload();
        }
Beispiel #10
0
        private ITest MakeTest(TestDomain testDomain, string assemblyName)
        {
            TestPackage package = new TestPackage(assemblyName);

            package.Settings["ShadowCopyFiles"] = false;

            return(testDomain.Load(package) ? testDomain.Test : null);
        }
Beispiel #11
0
        private TestRunner MakeTestRunner(string strTestModuleName)
        {
            TestPackage package    = new TestPackage(strTestModuleName);
            TestRunner  testRunner = new TestDomain();

            testRunner.Load(package);
            return(testRunner);
        }
		public void Init()
		{
			domain = new TestDomain();
			TestPackage package = new TestPackage( name );
			package.Assemblies.Add( path1 );
			package.Assemblies.Add( path2 );
			domain.Load( package );
			loadedSuite = domain.Test;
		}
 public void Init()
 {
     domain = new TestDomain();
     TestPackage package = new TestPackage( name );
     package.Assemblies.Add( path1 );
     package.Assemblies.Add( path2 );
     domain.Load( package );
     loadedSuite = domain.Test;
 }
Beispiel #14
0
        public void ResultStillValidAfterDomainUnload()
        {
            TestPackage package = new TestPackage(mockDll);

            Assert.IsTrue(domain.Load(package));
            TestResult result     = domain.Run(new NullListener());
            TestResult caseResult = findCaseResult(result);

            Assert.IsNotNull(caseResult);
            TestResultItem item    = new TestResultItem(caseResult);
            string         message = item.GetMessage();

            Assert.IsNotNull(message);
        }
        public void ResultStillValidAfterDomainUnload()
        {
            //TODO: This no longer appears to test anything
            TestPackage package = new TestPackage(mockDll);

            Assert.IsTrue(domain.Load(package));
            TestResult result     = domain.Run(new NullListener(), TestFilter.Empty, false, LoggingThreshold.Off);
            TestResult caseResult = findCaseResult(result);

            Assert.IsNotNull(caseResult);
            //TestResultItem item = new TestResultItem(caseResult);
            //string message = item.GetMessage();
            //Assert.IsNotNull(message);
        }
Beispiel #16
0
        public void ResultStillValidAfterDomainUnload()
        {
            TestPackage package = new TestPackage("mock-assembly.dll");

            Assert.IsTrue(domain.Load(package));
            TestResult      result = domain.Run(new NullListener());
            TestSuiteResult suite  = result as TestSuiteResult;

            Assert.IsNotNull(suite);
            TestCaseResult caseResult = findCaseResult(suite);

            Assert.IsNotNull(caseResult);
            TestResultItem item    = new TestResultItem(caseResult);
            string         message = item.GetMessage();

            Assert.IsNotNull(message);
        }
Beispiel #17
0
        public static void Main(string[] args)
        {
            NUnitBridge listener = null;

            try {
                listener = new NUnitBridge(Int32.Parse(args[0]));
                TestDomain domain = new TestDomain();
                domain.Load(args[1]);
                domain.Run(listener);
                listener.Close();
            } finally {
                if (listener != null)
                {
                    listener.Close();
                }
            }
        }
		public void LoadFixture()
		{
			TestDomain domain = new TestDomain();
			TestPackage package = new TestPackage( "Multiple Assemblies Test" );
			package.Assemblies.Add( Path.GetFullPath( "nonamespace-assembly.dll" ) );
			package.Assemblies.Add( Path.GetFullPath( "mock-assembly.dll" ) );
			package.TestName = "NUnit.Tests.Assemblies.MockTestFixture";
            try
            {
                domain.Load(package);
                Assert.AreEqual(MockTestFixture.Tests, domain.Test.TestCount);
            }
            finally
            {
                domain.Unload();
            }
		}
Beispiel #19
0
        public TestResult Execute(string configFileName, ITestFilter filter)
        {
            if (ServiceManager.Services.GetService(typeof(DomainManager)) == null)
            {
                ServiceManager.Services.AddService(new DomainManager());
                ServiceManager.Services.InitializeServices();
            }

            var package = new NBiPackage(BinPath, configFileName);

            var runner = new TestDomain();

            runner.Load(package);
            var testResult = runner.Run(new NullListener(), filter, false, LoggingThreshold.Warn);

            return(testResult);
        }
        public void LoadFixture()
        {
            TestDomain  domain  = new TestDomain();
            TestPackage package = new TestPackage("Multiple Assemblies Test");

            package.Assemblies.Add(NoNamespaceTestFixture.AssemblyPath);
            package.Assemblies.Add(MockAssembly.AssemblyPath);
            package.TestName = "NUnit.Tests.Assemblies.MockTestFixture";
            try
            {
                domain.Load(package);
                Assert.AreEqual(MockTestFixture.Tests, domain.Test.TestCount);
            }
            finally
            {
                domain.Unload();
            }
        }
Beispiel #21
0
        public void LoadTestsFromCompiledAssembly()
        {
            CompilerResults results = compiler.CompileCode(goodCode);

            Assert.AreEqual(0, results.NativeCompilerReturnValue);

            TestRunner runner = new TestDomain();

            try
            {
                Assert.IsTrue(runner.Load(new TestPackage(outputName)));
                Assert.AreEqual(2, runner.Test.TestCount);
            }
            finally
            {
                runner.Unload();
            }
        }
Beispiel #22
0
        private static Test MakeTestFromCommandLine(TestDomain testDomain, ConsoleOptions parser)
        {
            NUnitProject project;

            if (parser.IsTestProject)
            {
                project = NUnitProject.LoadProject((string)parser.Parameters[0]);
                string configName = (string)parser.config;
                if (configName != null)
                {
                    project.SetActiveConfig(configName);
                }
            }
            else
            {
                project = NUnitProject.FromAssemblies((string[])parser.Parameters.ToArray(typeof(string)));
            }

            return(testDomain.Load(project, parser.fixture));
        }
Beispiel #23
0
        public void ResultStillValidAfterDomainUnload()
        {
            TestDomain domain = new TestDomain(Console.Out, Console.Error);
            Test       test   = domain.Load("mock-assembly.dll");

            Assert.IsNotNull(test);
            TestResult      result = domain.Run(new NullListener());
            TestSuiteResult suite  = result as TestSuiteResult;

            Assert.IsNotNull(suite);
            TestCaseResult caseResult = findCaseResult(suite);

            Assert.IsNotNull(caseResult);
            TestResultItem item = new TestResultItem(caseResult);

            domain.Unload();
            string message = item.GetMessage();

            Assert.IsNotNull(message);
        }
        public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger messageLogger, ITestCaseDiscoverySink discoverySink)
        {
            TestLog.Initialize(messageLogger);
            if (RegistryFailure)
            {
                TestLog.SendErrorMessage(ErrorMsg);
            }
            Info("discovering tests", "started");

            // Ensure any channels registered by other adapters are unregistered
            CleanUpRegisteredChannels();

            // var initPath = Path.Combine(Environment.CurrentDirectory, "init.tml");

            var initPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NUnitTestAdapter");

            initPath = Path.Combine(initPath, "init.tml");

            var blackList = new List <string>();

            if (File.Exists(initPath))
            {
                var config = Toml.ReadFile <Configuration>(initPath);
                blackList = config.Blacklist.Select(b => b.ToLowerInvariant()).ToList();
            }


            foreach (string sourceAssembly in sources)
            {
                if (blackList.Contains(Path.GetFileName(sourceAssembly.ToLowerInvariant())))
                {
                    TestLog.SendDebugMessage("Ignore " + sourceAssembly);
                    continue;
                }

                TestLog.SendDebugMessage("Processing " + sourceAssembly);

                //config.Blacklist.Add(sourceAssembly);

                TestRunner    runner        = new TestDomain();
                var           package       = CreateTestPackage(sourceAssembly);
                TestConverter testConverter = null;
                try
                {
                    if (runner.Load(package))
                    {
                        testConverter = new TestConverter(TestLog, sourceAssembly);
                        int cases = ProcessTestCases(runner.Test, discoverySink, testConverter);
                        TestLog.SendDebugMessage(string.Format("Discovered {0} test cases", cases));
                    }
                    else
                    {
                        TestLog.NUnitLoadError(sourceAssembly);
                    }
                }
                catch (BadImageFormatException)
                {
                    // we skip the native c++ binaries that we don't support.
                    TestLog.AssemblyNotSupportedWarning(sourceAssembly);
                }

                catch (FileNotFoundException ex)
                {
                    // Probably from the GetExportedTypes in NUnit.core, attempting to find an assembly, not a problem if it is not NUnit here
                    TestLog.DependentAssemblyNotFoundWarning(ex.FileName, sourceAssembly);
                }
                catch (FileLoadException ex)
                {
                    // Attempts to load an invalid assembly, or an assembly with missing dependencies
                    TestLog.LoadingAssemblyFailedWarning(ex.FileName, sourceAssembly);
                }
                catch (UnsupportedFrameworkException ex)
                {
                    TestLog.UnsupportedFrameworkWarning(sourceAssembly);
                }
                catch (Exception ex)
                {
                    TestLog.SendErrorMessage("Exception thrown discovering tests in " + sourceAssembly, ex);
                }
                finally
                {
                    if (testConverter != null)
                    {
                        testConverter.Dispose();
                    }
                    runner.Unload();
                }
            }

            //Toml.WriteFile(config, @"test.tml");

            Info("discovering test", "finished");
        }
 public static void MakeAppDomain()
 {
     testDomain = new TestDomain();
     testDomain.Load( new TestPackage( "mock-assembly.dll" ) );
     loadedTest = testDomain.Test;
 }
		public void LoadFixture()
		{
			TestDomain domain = new TestDomain();
			TestPackage package = new TestPackage( "Multiple Assemblies Test" );
			package.Assemblies.Add( Path.GetFullPath( "nonamespace-assembly.dll" ) );
			package.Assemblies.Add( Path.GetFullPath( "mock-assembly.dll" ) );
			package.TestName = "NUnit.Tests.Assemblies.MockTestFixture";
            try
            {
                domain.Load(package);
                Assert.AreEqual(MockTestFixture.Tests, domain.Test.TestCount);
            }
            finally
            {
                domain.Unload();
            }
		}
 public void LoadFixture()
 {
     TestDomain domain = new TestDomain();
     TestPackage package = new TestPackage( "Multiple Assemblies Test" );
     package.Assemblies.Add(NoNamespaceTestFixture.AssemblyPath);
     package.Assemblies.Add(MockAssembly.AssemblyPath);
     package.TestName = "NUnit.Tests.Assemblies.MockTestFixture";
     try
     {
         domain.Load(package);
         Assert.AreEqual(MockTestFixture.Tests, domain.Test.TestCount);
     }
     finally
     {
         domain.Unload();
     }
 }
Beispiel #28
0
 public static void MakeAppDomain()
 {
     testDomain = new TestDomain();
     testDomain.Load(new TestPackage(mockDll));
     loadedTest = testDomain.Test;
 }
        public void LoadAssembly()
        {
            Test test = testDomain.Load("mock-assembly.dll");

            Assert.IsNotNull(test, "Test should not be null");
        }
Beispiel #30
0
 public void MakeAppDomain()
 {
     testDomain = new TestDomain();
     testDomain.Load(new TestPackage("mock-assembly.dll"));
     loadedTest = testDomain.Test;
 }
Beispiel #31
0
 public void FileNotFound()
 {
     testDomain.Load(new TestPackage("xxxx.dll"));
 }
        public void BuildSuite()
        {
            Test suite = domain.Load(name, assemblies);

            Assert.IsNotNull(suite);
        }
Beispiel #33
0
        public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger messageLogger, ITestCaseDiscoverySink discoverySink)
        {
            TestLog.Initialize(messageLogger);
            if (RegistryFailure)
            {
                TestLog.SendErrorMessage(ErrorMsg);
            }
            Info("discovering tests", "started");

            // Ensure any channels registered by other adapters are unregistered
            CleanUpRegisteredChannels();

            foreach (string sourceAssembly in sources)
            {
                TestLog.SendDebugMessage("Processing " + sourceAssembly);

                TestRunner    runner        = new TestDomain();
                var           package       = CreateTestPackage(sourceAssembly);
                TestConverter testConverter = null;
                try
                {
                    if (runner.Load(package))
                    {
                        testConverter = new TestConverter(TestLog, sourceAssembly);
                        int cases = ProcessTestCases(runner.Test, discoverySink, testConverter);
                        TestLog.SendDebugMessage(string.Format("Discovered {0} test cases", cases));
                    }
                    else
                    {
                        TestLog.NUnitLoadError(sourceAssembly);
                    }
                }
                catch (BadImageFormatException)
                {
                    // we skip the native c++ binaries that we don't support.
                    TestLog.AssemblyNotSupportedWarning(sourceAssembly);
                }

                catch (FileNotFoundException ex)
                {
                    // Probably from the GetExportedTypes in NUnit.core, attempting to find an assembly, not a problem if it is not NUnit here
                    TestLog.DependentAssemblyNotFoundWarning(ex.FileName, sourceAssembly);
                }
                catch (FileLoadException ex)
                {
                    // Attempts to load an invalid assembly, or an assembly with missing dependencies
                    TestLog.LoadingAssemblyFailedWarning(ex.FileName, sourceAssembly);
                }
                catch (UnsupportedFrameworkException ex)
                {
                    TestLog.UnsupportedFrameworkWarning(sourceAssembly);
                }
                catch (Exception ex)
                {
                    TestLog.SendErrorMessage("Exception thrown discovering tests in " + sourceAssembly, ex);
                }
                finally
                {
                    if (testConverter != null)
                    {
                        testConverter.Dispose();
                    }
                    runner.Unload();
                }
            }

            Info("discovering test", "finished");
        }
		public static void MakeAppDomain()
		{
			testDomain = new TestDomain();
			testDomain.Load( new TestPackage(mockDll));
			loadedTest = testDomain.Test;
		}