示例#1
0
// ReSharper disable InconsistentNaming
        internal virtual void Configure(TestModel model, ScriptedUnitTestContainer container)
// ReSharper restore InconsistentNaming
        {
            // describe units under test
            foreach (var unit in model.UnitsUnderTest)
                ModuleCache.Describe(container.Loader, unit);

            // describe unit testing framework
            LoadUnitTestingFramework(container);

            // describe unit testing extensions
            foreach(var extension in model.TestDependencies)
                ModuleCache.Describe(container.Loader, extension);

            // describe test suite
            var suiteDependencies =
                model.UnitsUnderTest
                    .Append(model.TestDependencies)
                    .Select(d => d.ScriptName)
                    .Append(ScriptedUnitTestContainer.PrexoniteUnitTestFramework)
                    .ToArray();
            var suiteDescription = new TestDependency
                {
                    ScriptName = model.TestSuiteScript, Dependencies = suiteDependencies
                };
            ModuleCache.Describe(container.Loader, suiteDescription);

            // Finally instantiate the test suite application(s)
            var result = ModuleCache.Load(model.TestSuiteScript);
            container.Application = result.Item1;
            container.PrintCompound();

            ITarget target = result.Item2;
            if (!target.IsSuccessful)
            {
                Console.WriteLine("The target {0} failed to build.", target.Name);

                if(target.Exception != null)
                    Console.WriteLine(target.Exception);

                foreach (var error in target.Messages.Where(m => m.Severity == MessageSeverity.Error))
                    Console.WriteLine("Error: {0}", error);
                foreach (var warning in target.Messages.Where(m => m.Severity == MessageSeverity.Warning))
                    Console.WriteLine("Warning: {0}", warning);
                foreach (var info in target.Messages.Where(m => m.Severity == MessageSeverity.Info))
                    Console.WriteLine("Info: {0}", info);

                Assert.Fail("The target {0} failed to build.", target.Name);
            }

            _prepareExecution(container);
        }
示例#2
0
        public static void Describe(Loader environment, TestDependency script)
        {
            EnsureFresh();

            var path = script.ScriptName;
            var dependencies = script.Dependencies ?? Enumerable.Empty<string>();

            var file = environment.ApplyLoadPaths(path);
            if (file == null || !file.Exists)
                throw new PrexoniteException(string.Format("Cannot find script {0}.", path));

            var moduleName = new ModuleName(Path.GetFileNameWithoutExtension(path), new Version(0, 0));

            if (Cache.TargetDescriptions.Contains(moduleName))
            {
                _trace.TraceEvent(TraceEventType.Verbose, 0,
                    "ModuleCache already contains a description of {0} on thread {1}, no action necessary.", moduleName,
                    Thread.CurrentThread.ManagedThreadId);
                return;
            }

            var dependencyNames =
                dependencies.Select(dep => 
                    new ModuleName(Path.GetFileNameWithoutExtension(dep), new Version(0, 0))).ToArray();

            // Manually add legacy symbol and stdlib dependencies
            var effectiveDependencies = dependencyNames.Append(LegacySymbolsDescription.Name).Append(StdlibDescription.Name);
            var desc = Cache.CreateDescription(moduleName, Source.FromFile(file,Encoding.UTF8), path, effectiveDependencies);
            _trace.TraceEvent(TraceEventType.Information, 0,
                "Adding new target description for cache on thread {0}: {1}.", Thread.CurrentThread.ManagedThreadId,
                desc);
            Cache.TargetDescriptions.Add(desc);
        }