public AddRequiresExecutor(ICSharpContextActionDataProvider provider, bool shouldBeGeneric, ICSharpFunctionDeclaration functionDeclaration, string parameterName, IClrTypeName propertyType) : this(provider, shouldBeGeneric, new []{functionDeclaration}, parameterName, propertyType) { Contract.Requires(provider != null); _provider = provider; }
public ContextElement GetOrCreateContext(string assemblyPath, IProject project, IClrTypeName typeName, string subject, ICollection<string> tags, bool isIgnored) { var id = ContextElement.CreateId(_elementIdFactory, _provider, project, subject, typeName.FullName, tags); var contextElement = this._manager.GetElementById(id) as ContextElement; if (contextElement != null) { contextElement.State = UnitTestElementState.Valid; contextElement.AssemblyLocation = assemblyPath; return contextElement; } return new ContextElement(this._provider, this._psiModuleManager, this._cacheManager, id, new ProjectModelElementEnvoy(project), typeName, assemblyPath, subject, tags, isIgnored, _categoryFactory); }
public IUnitTestElement GetOrCreateTestMethod(IProject project, IClrTypeName typeName, string methodName, string assemblyLocation, bool isParameterized) { var classElementId = GetClassElementId(project, typeName); var classElement = unitTestManager.GetElementById(project, classElementId) as TestClassElement; var id = string.Format("{0}.{1}", classElementId, methodName); var element = unitTestManager.GetElementById(project, id) as TestMethodElement; if (element != null) { element.State = UnitTestElementState.Valid; } else { element = new TestMethodElement( provider, classElement, new ProjectModelElementEnvoy(project), declaredElementProvider, id, typeName.GetPersistent(), methodName, assemblyLocation, isParameterized); } if (!classElement.Children.Contains(element)) classElement.Children.Add(element); return element; }
protected Element(MSpecUnitTestProvider provider, IPsi psiModuleManager, ICache cacheManager, Element parent, ProjectModelElementEnvoy projectEnvoy, IClrTypeName declaringTypeName, bool isIgnored) { if (declaringTypeName == null) { throw new ArgumentNullException("declaringTypeName"); } if (projectEnvoy != null) { this._projectEnvoy = projectEnvoy; } this._provider = provider; this._declaringTypeName = declaringTypeName; this._psiModuleManager = psiModuleManager; this._cacheManager = cacheManager; if (isIgnored) { this.ExplicitReason = "Ignored"; } this.TypeName = declaringTypeName; this.Parent = parent; this.Children = new List<IUnitTestElement>(); this.State = UnitTestElementState.Valid; this._taskFactory = new UnitTestTaskFactory(this._provider.ID); }
public ContextElement GetOrCreateContext(string assemblyPath, IProject project, IClrTypeName typeName, string subject, ICollection<string> tags, bool isIgnored) { var id = ContextElement.CreateId(subject, typeName.FullName, tags); var contextElement = _manager.GetElementById(project, id) as ContextElement; if (contextElement != null) { contextElement.State = UnitTestElementState.Valid; return contextElement; } return new ContextElement(_provider, _psiModuleManager, _cacheManager, new ProjectModelElementEnvoy(project), typeName, assemblyPath, subject, tags, isIgnored); }
public UnityType(IClrTypeName typeName, IEnumerable<UnityEventFunction> eventFunctions, Version minimumVersion, Version maximumVersion) { myTypeName = typeName; myMinimumVersion = minimumVersion; myMaximumVersion = maximumVersion; myEventFunctions = eventFunctions; }
public static List<OverridableMemberInstance> GetMissingMembersOf( this IClassLikeDeclaration declaration, IClrTypeName baseClassName) { Contract.Requires(declaration != null); Contract.Requires(declaration.DeclaredElement != null); Contract.Requires(baseClassName != null); Contract.Requires(baseClassName.FullName != null); Contract.Ensures(Contract.Result<List<OverridableMemberInstance>>() != null); var potentialOverrides = GenerateUtil.GetOverridableMembersOrder(declaration.DeclaredElement, false) .Where(e => e.DeclaringType.GetClrName().FullName == baseClassName.FullName) // This code provides two elements for property! So I'm trying to remove another instance! .Where(x => !x.Member.ShortName.StartsWith("get_")) .Where(x => !x.Member.ShortName.StartsWith("set_")) .ToList(); var alreadyOverriden = new HashSet<OverridableMemberInstance>( declaration.GetOverridenMembers()); var notOverridenMembers = new List<OverridableMemberInstance>(); foreach (var member in potentialOverrides) { if (!alreadyOverriden.Contains(member)) notOverridenMembers.Add(member); } return notOverridenMembers; }
protected Element(MSpecUnitTestProvider provider, Element parent, IClrTypeName declaringTypeName, UnitTestingCachingService cachingService, IUnitTestElementManager elementManager, bool isIgnored) { if (declaringTypeName == null) { throw new ArgumentNullException("declaringTypeName"); } this._provider = provider; this._declaringTypeName = declaringTypeName; this._cachingService = cachingService; this._elementManager = elementManager; if (isIgnored) { this.ExplicitReason = "Ignored"; } this.Parent = parent; this.Children = new BindableCollection <IUnitTestElement>(UT.Locks.ReadLock); this._taskFactory = new UnitTestTaskFactory(this._provider.ID); }
public XunitTestClassElement GetOrCreateTestClass(IProject project, IClrTypeName typeName, string assemblyLocation, OneToSetMap <string, string> traits) { var id = typeName.FullName; return(GetOrCreateTestClass(id, project, typeName, assemblyLocation, traits)); }
public AnnotationAttributeInstance(IClrTypeName clrTypeName, IPsiModule externalAnnotationsModule, IProject project, AttributeValue[] ctorArguments) { myClrTypeName = clrTypeName; myExternalAnnotationsModule = externalAnnotationsModule; myProject = project; myCtorArguments = ctorArguments; }
public XunitTestFakeElement(IUnitTestProvider provider, IProject project, IClrTypeName typeName, string methodName) { Provider = provider; myProject = project; TypeName = typeName; myMethodName = methodName; State = UnitTestElementState.Fake; }
protected ITypeElement CreateDeclaredType(IClrTypeName clrTypeName) { Contract.Requires(clrTypeName != null); Contract.Ensures(Contract.Result<ITypeElement>() != null); return new DeclaredTypeFromCLRName(clrTypeName, _psiModule, _currentFile.GetResolveContext()) .GetTypeElement(); }
private bool MethodSupportsRequires(out string parameterName, out IClrTypeName parameterType, out ReadOnlyCollection <ICSharpFunctionDeclaration> functionsToInsertPrecondition) { functionsToInsertPrecondition = null; return(ParameterSupportRequires(out parameterName, out parameterType) && FunctionSupportRequiers(parameterName, out functionsToInsertPrecondition)); }
private static string GetDisplayName(IClrTypeName typeName, string?subject) { var display = typeName.ShortName.ToFormat(); return(string.IsNullOrEmpty(subject) ? display : $"{subject}, {display}"); }
private static ITypeElement GetTypeElement(IClrTypeName typeName, IPsiModule module) { using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet()) { var type = TypeFactory.CreateTypeByCLRName(typeName, module); return(type.GetTypeElement()); } }
private static ITypeElement GetTypeElement(IClrTypeName typeName, KnownTypesCache knownTypesCache, IPsiModule module) { using (CompilationContextCookie.GetExplicitUniversalContextIfNotSet()) { var type = knownTypesCache.GetByClrTypeName(typeName, module); return(type.GetTypeElement()); } }
public UnityTestElement([NotNull] IProject project, [NotNull] IClrTypeName clrTypeName, UnitTestElementId id, UnityNUnitServiceProvider unityNUnitServiceProvider, string methodName) { myUnitTestingCachingService = unityNUnitServiceProvider.CachingService; myProject = project; myClrTypeName = clrTypeName; myId = id; myUnityNUnitServiceProvider = unityNUnitServiceProvider; myMethodName = methodName; }
public UnityEventFunctionParameter([NotNull] string name, [NotNull] IClrTypeName clrTypeName, [CanBeNull] string description, bool isArray, bool isOptional, string justification) { Name = name; ClrTypeName = clrTypeName; Description = description; IsArray = isArray; IsOptional = isOptional; Justification = justification; }
internal MethodRunnerElement(IProject project, IClrTypeName className, string methodName, bool isClassStatic, bool isMethodStatic, MethodRunnerProvider provider) { myProjectEnvoy = ProjectModelElementEnvoy.Create(project); myClassName = className; myMethodName = methodName; myIsClassStatic = isClassStatic; myIsMethodStatic = isMethodStatic; myProvider = provider; }
private IfThrowPrecondition(IIfStatement ifStatement, PredicateExpression predicateExpression, Message message, IClrTypeName exceptionTypeName) : base(ifStatement, predicateExpression, message) { Contract.Requires(ifStatement != null); Contract.Requires(exceptionTypeName != null); _ifStatement = ifStatement; _exceptionTypeName = exceptionTypeName; }
public static bool DerivesFrom(this IDeclaredElement candidate, IClrTypeName baseTypeName) { if (!(candidate is ITypeElement element)) { return(false); } var baseType = GetTypeElement(baseTypeName, element.Module); return(element.IsDescendantOf(baseType)); }
public ContextElement( UnitTestElementId id, IClrTypeName typeName, MspecServiceProvider serviceProvider, string subject, bool isIgnored) : base(id, null, typeName, serviceProvider, isIgnored) { _subject = subject; }
public static bool IsDescendantOf([NotNull] IClrTypeName unityTypeClrName, [CanBeNull] ITypeElement type) { if (type == null) { return(false); } var mb = TypeFactory.CreateTypeByCLRName(unityTypeClrName, type.Module); return(type.IsDescendantOf(mb.GetTypeElement())); }
public XunitInheritedTestMethodContainerElement(IUnitTestProvider provider, ProjectModelElementEnvoy projectModelElementEnvoy, string id, IClrTypeName typeName, string methodName) : base(provider, null, id, projectModelElementEnvoy, new JetHashSet <string>()) { TypeName = typeName; this.methodName = methodName; ShortName = methodName; SetState(UnitTestElementState.Fake); ExplicitReason = null; }
public IDeclaredElement GetDeclaredElement(IProject project, IClrTypeName typeName) { var modules = psiServices.Modules; var psiModule = modules.GetPrimaryPsiModule(project); if (psiModule == null) return null; var symbolScope = psiServices.Symbols.GetSymbolScope(psiModule, project.GetResolveContext(), true, true); return symbolScope.GetTypeElementByCLRName(typeName); }
public static void RemoveAttributeFromSingleDeclaration([CanBeNull] IFieldDeclaration fieldDeclaration, IClrTypeName attributeTypeName) { var attribute = GetAttribute(fieldDeclaration, attributeTypeName); if (attribute != null) { fieldDeclaration.RemoveAttribute(attribute); } }
public XunitInheritedTestMethodContainerElement(IUnitTestProvider provider, ProjectModelElementEnvoy projectModelElementEnvoy, string id, IClrTypeName typeName, string methodName) : base(provider, null, id, projectModelElementEnvoy, EmptyArray <UnitTestElementCategory> .Instance) { TypeName = typeName; this.methodName = methodName; ShortName = methodName; SetState(UnitTestElementState.Fake); ExplicitReason = null; }
public static void RemoveAttributeFromAllDeclarations([CanBeNull] IFieldDeclaration fieldDeclaration, IClrTypeName attributeTypeName) { var attribute = GetAttribute(fieldDeclaration, attributeTypeName); if (attribute != null) { CSharpSharedImplUtil.RemoveAttribute(fieldDeclaration, attribute); } }
public BehaviorSpecificationElement( UnitTestElementId id, IUnitTestElement parent, IClrTypeName typeName, MspecServiceProvider serviceProvider, string fieldName, bool isIgnored) : base(id, parent, typeName, serviceProvider, fieldName, isIgnored || parent.Explicit) { }
private IfThrowPrecondition(IIfStatement ifStatement, PredicateExpression predicateExpression, Message message, IClrTypeName exceptionTypeName) : base(ifStatement, predicateExpression, message) { Contract.Requires(ifStatement != null); Contract.Requires(exceptionTypeName != null); _ifStatement = ifStatement; _exceptionTypeName = exceptionTypeName; }
private void ProcessTestClass(IClrTypeName typeName, IEnumerable<IMethodInfo> methods, XunitTestClassElement parent) { XunitTestClassElement classElement = factory.GetOrCreateClassElement(typeName, project, envoy, parent); consumer(classElement); foreach (IMethodInfo method in methods) { ProcessTestMethod(classElement, method); } }
public XunitInheritedTestMethodContainerElement(XunitServiceProvider services, UnitTestElementId id, IClrTypeName typeName, string methodName) : base(services, id, typeName) { this.methodName = methodName; ShortName = methodName; // ReSharper disable once RedundantBaseQualifier base.State = UnitTestElementState.Fake; }
public static void RemoveAttributeFromSingleDeclaration([CanBeNull] IFieldDeclaration fieldDeclaration, IClrTypeName attributeTypeName) { var attribute = GetAttribute(fieldDeclaration, attributeTypeName); if (attribute != null) { // This will split a multiple declaration, if necessary fieldDeclaration.RemoveAttribute(attribute); } }
protected FieldElement(MSpecUnitTestProvider provider, Element parent, IClrTypeName declaringTypeName, UnitTestingCachingService cachingService, IUnitTestElementManager elementManager, string fieldName, bool isIgnored) : base(provider, parent, declaringTypeName, cachingService, elementManager, isIgnored || parent.Explicit) { this._fieldName = fieldName; }
public static bool DerivesFrom([CanBeNull] this ITypeElement candidate, IClrTypeName baseTypeName) { if (candidate == null) { return(false); } var knownTypesCache = candidate.GetSolution().GetComponent <KnownTypesCache>(); var baseType = GetTypeElement(baseTypeName, knownTypesCache, candidate.Module); return(candidate.IsDescendantOf(baseType)); }
public UnityMessage([NotNull] string name, [NotNull] string typeName, [NotNull] IClrTypeName returnType, bool returnTypeIsArray, bool isStatic, string description, [NotNull] params UnityMessageParameter[] parameters) { Description = description; myIsStatic = isStatic; Name = name; TypeName = typeName; myReturnType = returnType; myReturnTypeIsArray = returnTypeIsArray; myParameters = parameters.Length > 0 ? parameters : EmptyArray <UnityMessageParameter> .Instance; }
protected FieldElement( UnitTestElementId id, IUnitTestElement parent, IClrTypeName typeName, MspecServiceProvider serviceProvider, string fieldName, bool isIgnored) : base(id, parent, typeName, serviceProvider, isIgnored || parent.Explicit) { FieldName = fieldName; }
public XunitTestMethodElement(XunitServiceProvider services, UnitTestElementId id, IClrTypeName typeName, string methodName, string skipReason, bool isDynamic) : base(services, id, typeName) { MethodName = methodName; ExplicitReason = skipReason; IsDynamic = isDynamic; ShortName = MethodName; }
private static string GetTestMethodId(XunitTestClassElement classElement, IClrTypeName typeName, string methodName) { var baseTypeName = string.Empty; if (!classElement.TypeName.Equals(typeName)) { baseTypeName = typeName.ShortName + "."; } return(string.Format("{0}.{1}{2}", classElement.Id, baseTypeName, methodName)); }
protected XunitTestElementBase([NotNull] XunitServiceProvider provider, ProjectModelElementEnvoy project, string id, IClrTypeName typeName) { if (provider == null) throw new ArgumentNullException("provider"); if (project == null) throw new ArgumentNullException("project"); this.provider = provider; this.project = project; TypeName = typeName; Id = id; }
protected XunitBaseElement(XunitServiceProvider services, UnitTestElementId id, IClrTypeName typeName) { Services = services; TypeName = typeName; Id = id; Children = new BindableCollection <IUnitTestElement>(EternalLifetime.Instance, UT.Locks.ReadLock); ExplicitReason = string.Empty; Categories = EmptyArray <UnitTestElementCategory> .Instance; }
public XunitTestClassElement(IUnitTestProvider provider, ProjectModelElementEnvoy projectModelElementEnvoy, DeclaredElementProvider declaredElementProvider, string id, IClrTypeName typeName, string assemblyLocation, IEnumerable <UnitTestElementCategory> categories) : base(provider, null, id, projectModelElementEnvoy, categories) { this.declaredElementProvider = declaredElementProvider; AssemblyLocation = assemblyLocation; TypeName = typeName; ShortName = string.Join("+", typeName.TypeNames.Select(FormatTypeName).ToArray()); }
protected XunitBaseElement(XunitServiceProvider services, UnitTestElementId id, IClrTypeName typeName) { Services = services; TypeName = typeName; Id = id; Children = new BindableCollection<IUnitTestElement>(EternalLifetime.Instance, UT.Locks.ReadLock); ExplicitReason = string.Empty; Categories = EmptyArray<UnitTestElementCategory>.Instance; }
public TestMethodElement(TestProvider provider, IUnitTestElement parent, ProjectModelElementEnvoy projectModelElementEnvoy, DeclaredElementProvider declaredElementProvider, string id, IClrTypeName typeName, string methodName, string assemblyLocation, bool isParameterized) : base(provider, typeName, assemblyLocation, parent, id, projectModelElementEnvoy) { this.declaredElementProvider = declaredElementProvider; this.methodName = methodName; IsParameterized = isParameterized; ShortName = methodName; presentation = string.Format("{0}.{1}", typeName.ShortName, methodName); }
private static bool IsPredefinedType([CanBeNull] IType type, [NotNull] IClrTypeName clrName) { var predefinedCandidate = type as IDeclaredType; if (predefinedCandidate == null) { return(false); } return(IsPredefinedTypeElement(predefinedCandidate.GetTypeElement(), clrName)); }
protected FieldElement(MSpecUnitTestProvider provider, IPsi psiModuleManager, ICache cacheManager, Element parent, ProjectModelElementEnvoy projectEnvoy, IClrTypeName declaringTypeName, string fieldName, bool isIgnored) : base(provider, psiModuleManager, cacheManager, parent, projectEnvoy, declaringTypeName, isIgnored || parent.Explicit) { this._fieldName = fieldName; }
public SpecificationContainerElement GetOrCreateSpecificationContainerElement(IProject project, IClrTypeName typeName, string assemblyLocation) { var id = "simple:" + typeName.FullName; var element = _unitTestManager.GetElementById(project, id); if (element != null) { element.State = UnitTestElementState.Valid; return element as SpecificationContainerElement; } return new SpecificationContainerElement(_provider, new ProjectModelElementEnvoy(project), _cacheManager, _psiModuleManager, id, typeName.GetPersistent(), assemblyLocation); }
public SpecificationElement GetOrCreateSpecificationElement(IProject project, SpecificationContainerElement parent, IClrTypeName typeName, string methodName, string skipReason) { var id = string.Format("simple:{0}.{1}", parent.TypeName.FullName, methodName); var element = _unitTestManager.GetElementById(project, id); if (element != null) { element.State = UnitTestElementState.Valid; return element as SpecificationElement; } return new SpecificationElement(_provider, parent, new ProjectModelElementEnvoy(project), _cacheManager, _psiModuleManager, id, typeName.GetPersistent(), methodName, skipReason); }
public override bool HasAttributeInstance(IClrTypeName clrTypeName) { if (AttributeClassNames.Contains(clrTypeName.ShortName)) { return(false); } // todo: get entity without getting declaration var entity = (GetDeclaration() as IFSharpTypeDeclaration)?.GetFSharpSymbol() as FSharpEntity; return(entity?.Attributes.HasAttributeInstance(clrTypeName.FullName) ?? false); }
public static XunitTestMethodElement CreateTestMethod(IUnitTestProvider provider, IProject project, DeclaredElementProvider declaredElementProvider, XunitTestClassElement classElement, IClrTypeName typeName, string methodName, string skipReason, IEnumerable<UnitTestElementCategory> categories, bool isDynamic = false) { var id = GetTestMethodId(classElement, typeName, methodName); return new XunitTestMethodElement(provider, classElement, new ProjectModelElementEnvoy(project), declaredElementProvider, id, typeName.GetPersistent(), methodName, skipReason, categories, isDynamic); }
protected FieldElement(MSpecUnitTestProvider provider, PsiModuleManager psiModuleManager, CacheManager cacheManager, Element parent, ProjectModelElementEnvoy projectEnvoy, IClrTypeName declaringTypeName, string fieldName, bool isIgnored) : base(provider, psiModuleManager, cacheManager, parent, projectEnvoy, declaringTypeName, isIgnored || parent.Explicit) { _fieldName = fieldName; State = UnitTestElementState.Valid; }
public XunitTestMethodElement GetOrCreateTestMethod(IProject project, XunitTestClassElement testClassElement, IClrTypeName typeName, string methodName, string skipReason, MultiValueDictionary<string, string> traits, bool isDynamic) { var categories = GetCategories(traits); var element = GetTestMethod(project, testClassElement, typeName, methodName); if (element != null) { element.State = UnitTestElementState.Valid; element.SetCategories(categories); return element; } return CreateTestMethod(provider, project, declaredElementProvider, testClassElement, typeName, methodName, skipReason, categories, isDynamic); }
public BehaviorSpecificationElement(MSpecUnitTestProvider provider, PsiModuleManager psiModuleManager, CacheManager cacheManager, // ReSharper disable SuggestBaseTypeForParameter BehaviorElement behavior, // ReSharper restore SuggestBaseTypeForParameter ProjectModelElementEnvoy projectEnvoy, IClrTypeName declaringTypeName, string fieldName, bool isIgnored) : base(provider, psiModuleManager, cacheManager, behavior, projectEnvoy, declaringTypeName, fieldName, isIgnored || behavior.Explicit) { _id = CreateId(behavior, fieldName); }
protected BaseElement(TestProvider provider, IClrTypeName typeName, string assemblyLocation, IUnitTestElement parent, string id, ProjectModelElementEnvoy projectModelElementEnvoy) { this.provider = provider; this.id = id; this.projectModelElementEnvoy = projectModelElementEnvoy; TypeName = typeName; AssemblyLocation = assemblyLocation; Parent = parent; Children = new List<IUnitTestElement>(); SetState(UnitTestElementState.Valid); }
public static bool IsInsideElement(this CSharpCodeCompletionContext context, IClrTypeName typeName) { ITreeNode nodeAt = context.BasicContext.File.FindNodeAt(context.BasicContext.CaretDocumentRange); if (nodeAt?.Parent == null) return false; var csharpArgument = (nodeAt.Parent is ICSharpArgument ? nodeAt.Parent : nodeAt.Parent.Parent) as ICSharpArgument; var attribute = (csharpArgument != null ? csharpArgument.Parent : nodeAt.Parent) as IAttribute; var typeElement = attribute?.TypeReference?.Resolve().DeclaredElement as ITypeElement; if (typeElement == null) return false; return typeElement.GetClrName().Equals(typeName); }
public AddRequiresExecutor(ICSharpContextActionDataProvider provider, bool shouldBeGeneric, IEnumerable<ICSharpFunctionDeclaration> functionsDeclaration, string parameterName, IClrTypeName propertyType) : base(provider) { Contract.Requires(functionsDeclaration != null); Contract.Requires(parameterName != null); Contract.Requires(propertyType != null); _provider = provider; _shouldBeGeneric = shouldBeGeneric; _functionsDeclaration = functionsDeclaration; _parameterName = parameterName; _propertyType = propertyType; }
public BehaviorElement(MSpecUnitTestProvider provider, PsiModuleManager psiModuleManager, CacheManager cacheManager, // ReSharper disable SuggestBaseTypeForParameter ContextElement context, // ReSharper restore SuggestBaseTypeForParameter ProjectModelElementEnvoy projectEnvoy, IClrTypeName declaringTypeName, string fieldName, bool isIgnored, string fullyQualifiedTypeName) : base(provider, psiModuleManager, cacheManager, context, projectEnvoy, declaringTypeName, fieldName, isIgnored || context.Explicit) { _id = CreateId(context, fieldName); FullyQualifiedTypeName = fullyQualifiedTypeName; }
public UnityEventFunction([NotNull] string name, [NotNull] string typeName, [NotNull] IClrTypeName returnType, bool returnTypeIsArray, bool isStatic, string description, bool undocumented, Version minimumVersion, Version maximumVersion, [NotNull] params UnityEventFunctionParameter[] parameters) { Description = description; Undocumented = undocumented; myIsStatic = isStatic; myMinimumVersion = minimumVersion; myMaximumVersion = maximumVersion; Name = name; TypeName = typeName; myReturnType = returnType; myReturnTypeIsArray = returnTypeIsArray; myParameters = parameters.Length > 0 ? parameters : EmptyArray<UnityEventFunctionParameter>.Instance; }
public ContextSpecificationElement(MSpecUnitTestProvider provider, IPsi psiModuleManager, ICache cacheManager, ProjectModelElementEnvoy project, ContextElement context, IClrTypeName declaringTypeName, string fieldName, bool isIgnored) : base(provider, psiModuleManager, cacheManager, context, project, declaringTypeName, fieldName, isIgnored || context.Explicit) { this._id = CreateId(provider, context, fieldName); }
public ContextElement(MSpecUnitTestProvider provider, IPsi psiModuleManager, ICache cacheManager, ProjectModelElementEnvoy projectEnvoy, IClrTypeName typeName, string assemblyLocation, string subject, IEnumerable<string> tags, bool isIgnored) : base(provider, psiModuleManager, cacheManager, null, projectEnvoy, typeName, isIgnored) { _id = CreateId(subject, TypeName.FullName, tags); _assemblyLocation = assemblyLocation; _subject = subject; if (tags != null) { _categories = UnitTestElementCategory.Create(new JetHashSet<string>(tags)); } }