Ejemplo n.º 1
0
        /// <inheritdoc />
        public IEnumerable <IDataItem> Merge(IList <IDataProvider> providers, ICollection <DataBinding> bindings,
                                             bool includeDynamicItems)
        {
            var previousValues = new GallioHashSet <object[]>(new ArrayEqualityComparer <object>());

            foreach (IDataProvider provider in providers)
            {
                foreach (IDataItem item in provider.GetItems(bindings, includeDynamicItems))
                {
                    try
                    {
                        object[] values = GenericCollectionUtils.ConvertAllToArray <DataBinding, object>(bindings, delegate(DataBinding binding)
                        {
                            return(item.GetValue(binding));
                        });

                        if (previousValues.Contains(values))
                        {
                            continue;
                        }

                        previousValues.Add(values);
                    }
                    catch
                    {
                        // Always consider items whose bindings cannot be evaluated correctly as distinct.
                    }

                    yield return(item);
                }
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Obtains a unique local id for a child of this test.
        /// </summary>
        /// <param name="localIdHint">A suggested id which will be used if no conflicts occur.</param>
        /// <returns>The unique local id to use.</returns>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="localIdHint"/> is null.</exception>
        public string GetUniqueLocalIdForChild(string localIdHint)
        {
            if (localIdHint == null)
            {
                throw new ArgumentNullException("localIdHint");
            }

            string candidateLocalId = localIdHint;

            if (assignedChildLocalIds == null)
            {
                assignedChildLocalIds = new GallioHashSet <string>();
            }
            else
            {
                int index = 2;
                while (assignedChildLocalIds.Contains(candidateLocalId))
                {
                    candidateLocalId = localIdHint + index;
                    index           += 1;
                }
            }

            assignedChildLocalIds.Add(candidateLocalId);
            return(candidateLocalId);
        }
Ejemplo n.º 3
0
 public ImmutableTypeCollection()
 {
     types = new GallioHashSet <Type>
     {
         typeof(Boolean),
         typeof(Int16),
         typeof(Int32),
         typeof(Int64),
         typeof(IntPtr),
         typeof(UInt16),
         typeof(UInt32),
         typeof(UInt64),
         typeof(UIntPtr),
         typeof(Single),
         typeof(Double),
         typeof(Decimal),
         typeof(Byte),
         typeof(Char),
         typeof(String),
         typeof(DateTime),
         typeof(TimeSpan),
         typeof(ReadOnlyCollectionBase),
         typeof(ReadOnlyCollection <>),
         typeof(ReadOnlyDictionary <,>),
     };
 }
Ejemplo n.º 4
0
 /// <summary>
 /// Creates a file system plugin loader.
 /// </summary>
 public PluginLoader()
 {
     pluginPaths = new List <string>();
     pluginXmls  = new List <Pair <string, DirectoryInfo> >();
     initialPreprocessorConstants = new GallioHashSet <string>();
     InstallationId = Guid.Empty;
 }
Ejemplo n.º 5
0
        /// <summary>
        /// Loads plugins by recursively searching the plugin paths for *.plugin files.
        /// </summary>
        /// <param name="pluginCallback">A function that receives plugin metadata as it
        ///   becomes available, not null.</param>
        /// <param name="progressMonitor"></param>
        protected virtual void LoadPlugins(PluginCallback pluginCallback, IProgressMonitor progressMonitor)
        {
            if (pluginPaths.Count == 0)
            {
                return;
            }

            var uniquePluginFilePaths = new GallioHashSet <string>();

            using (progressMonitor.BeginTask("Loading plugins", pluginPaths.Count))
            {
                foreach (var pluginPath in pluginPaths)
                {
                    using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(1))
                    {
                        var pluginDirectory = new DirectoryInfo(pluginPath);
                        if (pluginDirectory.Exists)
                        {
                            LoadPluginsFromDirectory(pluginDirectory, uniquePluginFilePaths, pluginCallback, subProgressMonitor);
                        }
                        else
                        {
                            var pluginFile = new FileInfo(pluginPath);
                            if (pluginFile.Exists)
                            {
                                LoadPluginsFromFile(pluginFile, uniquePluginFilePaths, pluginCallback, subProgressMonitor);
                            }
                        }
                    }
                }
            }
        }
Ejemplo n.º 6
0
        /// <inheritdoc />
        public override IList <IEventInfo> GetEvents(BindingFlags bindingFlags)
        {
            List <IEventInfo> result = new List <IEventInfo>();

            AddAll(result, EnumerateEvents(bindingFlags, this));

            BindingFlags inheritanceBindingFlags = GetInheritanceBindingFlags(bindingFlags);

            if (inheritanceBindingFlags != BindingFlags.Default)
            {
                GallioHashSet <StaticEventWrapper> overrides = new GallioHashSet <StaticEventWrapper>();
                foreach (StaticEventWrapper @event in result)
                {
                    AddAll(overrides, @event.GetOverridenOrHiddenEvents(false));
                }

                foreach (StaticDeclaredTypeWrapper baseType in GetAllBaseTypes())
                {
                    foreach (StaticEventWrapper inheritedEvent in baseType.EnumerateEvents(inheritanceBindingFlags, this))
                    {
                        if (!overrides.Contains(inheritedEvent))
                        {
                            result.Add(inheritedEvent);
                            AddAll(overrides, inheritedEvent.GetOverridenOrHiddenEvents(false));
                        }
                    }
                }
            }

            return(result);
        }
Ejemplo n.º 7
0
        private IList <IMethodInfo> GetMethods(BindingFlags bindingFlags, bool excludeOverridesOnly)
        {
            List <IMethodInfo> result = new List <IMethodInfo>();

            AddAll(result, EnumerateDeclaredMethods(bindingFlags, this));

            BindingFlags inheritanceBindingFlags = GetInheritanceBindingFlags(bindingFlags);

            if (inheritanceBindingFlags != BindingFlags.Default)
            {
                GallioHashSet <StaticMethodWrapper> overrides = new GallioHashSet <StaticMethodWrapper>();
                foreach (StaticMethodWrapper method in result)
                {
                    AddAll(overrides, method.GetOverridenOrHiddenMethods(excludeOverridesOnly));
                }

                foreach (StaticDeclaredTypeWrapper baseType in GetAllBaseTypes())
                {
                    foreach (StaticMethodWrapper inheritedMethod in baseType.EnumerateDeclaredMethods(inheritanceBindingFlags, this))
                    {
                        if (!overrides.Contains(inheritedMethod) && !IsSpecialNonInheritedMethod(inheritedMethod))
                        {
                            result.Add(inheritedMethod);
                            AddAll(overrides, inheritedMethod.GetOverridenOrHiddenMethods(excludeOverridesOnly));
                        }
                    }
                }
            }

            return(result);
        }
Ejemplo n.º 8
0
 private void RegisterAttachment(string attachmentName)
 {
     if (attachmentNames == null)
     {
         attachmentNames = new GallioHashSet <string>();
     }
     attachmentNames.Add(attachmentName);
 }
Ejemplo n.º 9
0
        /// <inheritdoc />
        protected override void Initialize()
        {
            var testCaseSteps = new GallioHashSet <string>();

            Events.AnnotationDiscovered += delegate(object sender, AnnotationDiscoveredEventArgs e)
            {
                LogAnnotation(e.Annotation);
            };

            Events.TestStepStarted += delegate(object sender, TestStepStartedEventArgs e)
            {
                if (e.TestStepRun.Step.IsTestCase)
                {
                    testCaseSteps.Add(e.TestStepRun.Step.Id);

                    LogTestCaseStarted(e);
                }
                else
                {
                    string parentId = e.TestStepRun.Step.ParentId;
                    if (parentId != null && testCaseSteps.Contains(parentId))
                    {
                        testCaseSteps.Add(e.TestStepRun.Step.Id);
                    }
                }
            };

            Events.TestStepFinished += delegate(object sender, TestStepFinishedEventArgs e)
            {
                if (e.TestStepRun.Step.IsTestCase)
                {
                    testCaseSteps.Remove(e.TestStepRun.Step.Id);

                    LogTestCaseFinished(e);
                }
                else
                {
                    if (!testCaseSteps.Contains(e.TestStepRun.Step.Id))
                    {
                        if (e.TestStepRun.Result.Outcome.Status != TestStatus.Passed &&
                            (e.TestStepRun.TestLog.GetStream(MarkupStreamNames.Warnings) != null ||
                             e.TestStepRun.TestLog.GetStream(MarkupStreamNames.Failures) != null))
                        {
                            LogNonTestCaseProblem(e);
                        }
                    }
                    else
                    {
                        testCaseSteps.Remove(e.TestStepRun.Step.Id);
                    }
                }
            };
        }
Ejemplo n.º 10
0
 /// <summary>
 /// Closes the markup document writer.
 /// </summary>
 public void Close()
 {
     lock (this)
     {
         if (!isClosed)
         {
             CloseImpl();
             isClosed        = true;
             attachmentNames = null;
             streamDepths    = null;
         }
     }
 }
Ejemplo n.º 11
0
        /// <summary>
        /// Prepares to populate the children of the assembly test on demand by
        /// adding a deferred populator with <see cref="IPatternScope.AddDeferredComponentPopulator" />.
        /// </summary>
        /// <param name="assemblyScope">The assembly scope.</param>
        /// <param name="assembly">The assembly.</param>
        protected virtual void PrepareToPopulateChildrenOnDemand(IPatternScope assemblyScope, IAssemblyInfo assembly)
        {
            var populatedTypes = new GallioHashSet <ITypeInfo>();

            assemblyScope.AddDeferredComponentPopulator(childCodeElementHint =>
            {
                ITypeInfo type = childCodeElementHint as ITypeInfo;
                if (type != null && !type.IsNested && !populatedTypes.Contains(type) && assembly.Equals(type.Assembly))
                {
                    populatedTypes.Add(type);
                    assemblyScope.Consume(type, false, DefaultTypePattern);
                }
            });
        }
Ejemplo n.º 12
0
        public HtmlTestStepRunFormatter()
        {
            var runtime       = RuntimeAccessor.Instance;
            var resourcesPath = runtime.ResourceLocator.ResolveResourcePath(new Uri("plugin://Gallio.Reports/Resources/"));

            resourcesUrl = new Uri(resourcesPath);
            cssUrl       = new Uri(resourcesUrl, "css");
            imgUrl       = new Uri(resourcesUrl, "img");
            jsDir        = Path.Combine(resourcesPath, "js");

            cache           = new TemporaryDiskCache("Gallio.UI");
            cacheGroup      = cache.Groups[Guid.NewGuid().ToString()];
            reportFilePool  = new ReportFilePool(cacheGroup, 5);
            attachmentPaths = new GallioHashSet <string>();
        }
Ejemplo n.º 13
0
 /// <summary>
 /// Creates an Xml preprocessor.
 /// </summary>
 public XmlPreprocessor()
 {
     constants = new GallioHashSet <string>();
 }
Ejemplo n.º 14
0
 /// <summary>
 /// Creates an empty task container.
 /// </summary>
 public TaskContainer()
 {
     activeTasks = new GallioHashSet <Task>();
 }
        private TestFrameworkSelection GetFallbackSelection(
            Dictionary <object, TestFrameworkSelection> selections,
            IList <AssemblyName> assemblyReferences,
            IEnumerable <ComponentHandle <ITestFramework, TestFrameworkTraits> > filteredTestFrameworkHandlesWithoutFallback,
            TestFrameworkOptions testFrameworkOptions,
            TestFrameworkFallbackMode testFrameworkFallbackMode)
        {
            // Strict fallback mode.
            if (testFrameworkFallbackMode == TestFrameworkFallbackMode.Strict)
            {
                return(null);
            }

            // Approximate fallback mode.
            if (assemblyReferences != null)
            {
                GallioHashSet <string> matchingReferences = null;
                GallioHashSet <string> matchingSignatures = null;

                foreach (var testFrameworkHandle in filteredTestFrameworkHandlesWithoutFallback)
                {
                    IList <AssemblySignature> assemblySignatures = testFrameworkHandle.GetTraits().FrameworkAssemblies;

                    foreach (AssemblyName assemblyName in assemblyReferences)
                    {
                        foreach (AssemblySignature assemblySignature in assemblySignatures)
                        {
                            if (assemblySignature.Name == assemblyName.Name)
                            {
                                if (matchingReferences == null)
                                {
                                    matchingReferences = new GallioHashSet <string>();
                                    matchingSignatures = new GallioHashSet <string>();
                                }

                                matchingReferences.Add(assemblyName.FullName);
                                matchingSignatures.Add(assemblySignature.ToString());
                            }
                        }
                    }
                }

                if (matchingReferences != null)
                {
                    StringBuilder fallbackExplanationBuilder = new StringBuilder();

                    fallbackExplanationBuilder.Append("Detected a probable test framework assembly version mismatch.\n");

                    fallbackExplanationBuilder.Append("Referenced test frameworks: ");
                    AppendQuotedItems(fallbackExplanationBuilder, matchingReferences);
                    fallbackExplanationBuilder.Append(".\n");

                    fallbackExplanationBuilder.Append("Supported test frameworks: ");
                    AppendQuotedItems(fallbackExplanationBuilder, matchingSignatures);
                    fallbackExplanationBuilder.Append(".");

                    string fallbackExplanation = fallbackExplanationBuilder.ToString();
                    return(GetOrCreateSelectionIfAbsent(selections, fallbackExplanation, () =>
                    {
                        TestFrameworkOptions fallbackTestFrameworkOptions = testFrameworkOptions.Copy();
                        fallbackTestFrameworkOptions.AddProperty(FallbackTestFramework.FallbackExplanationKey,
                                                                 fallbackExplanation);
                        return new TestFrameworkSelection(fallbackTestFrameworkHandle, fallbackTestFrameworkOptions,
                                                          true);
                    }));
                }
            }

            if (testFrameworkFallbackMode == TestFrameworkFallbackMode.Approximate)
            {
                return(null);
            }

            // Default fallback mode.
            return(GetOrCreateSelectionIfAbsent(selections, DefaultFallbackSelectionKey,
                                                () => new TestFrameworkSelection(fallbackTestFrameworkHandle, testFrameworkOptions, true)));
        }