private bool IsValidFixtureType(ITypeInfo typeInfo, ref string reason)
        {
            if (typeInfo.IsAbstract)
            {
                reason = string.Format("{0} is an abstract class", typeInfo.FullName);
                return false;
            }

            if (!typeInfo.HasConstructor(new Type[0]))
            {
                reason = string.Format("{0} does not have a default constructor", typeInfo.FullName);
                return false;
            }

            var invalidAttributes = new Type[] { 
                typeof(SetUpAttribute), 
                typeof(TearDownAttribute),
#pragma warning disable 618 // Obsolete Attributes
                typeof(TestFixtureSetUpAttribute), 
                typeof(TestFixtureTearDownAttribute) };
#pragma warning restore

            foreach (Type invalidType in invalidAttributes)
                if (typeInfo.HasMethodWithAttribute(invalidType))
                {
                    reason = invalidType.Name + " attribute not allowed in a SetUpFixture";
                    return false;
                }

            return true;
        }

 public IntPtr GetVarDesc(ITypeInfo typeInfo, int index)
 {
     if (typeInfo == null) throw new ArgumentNullException(nameof(typeInfo));
     IntPtr ret;
     typeInfo.GetVarDesc(index, out ret);
     return ret;
 }

 public override IEnumerable<Attribute> GetAttributes(ITypeInfo typesInfo) {
     if (typesInfo.Type != typeof(Analysis)) yield break;
     yield return new CloneViewAttribute(CloneViewType.DetailView, InPlaceEdit_DetailView);
     yield return new XpandNavigationItemAttribute("PivotChart/In Place Edit", InPlaceEdit_DetailView) { ObjectKey = "Name='InPlaceEdit'" };
     yield return new DisplayFeatureModelAttribute(InPlaceEdit_DetailView, new BinaryOperator("Name", "InPlaceEdit"));
     yield return new ActionStateRuleAttribute("Hide_save_and_close_for_" + InPlaceEdit_DetailView, "SaveAndClose", "1=1", "1=1", ActionState.Hidden);
 }

 public override IEnumerable<Attribute> GetAttributes(ITypeInfo typesInfo) {
     if (typesInfo.Type != typeof(Customer)) yield break;
     yield return new AdditionalViewControlsRuleAttribute(Captions.ViewMessage + " " + Captions.HeaderLinqQuery, "1=1", "1=1", Captions.ViewMessageLinqQuery, Position.Bottom) { ViewType = ViewType.ListView, View = "Customer_ListView_EmployeesLinq_Linq" };
     yield return new AdditionalViewControlsRuleAttribute(Captions.Header + " " + Captions.HeaderLinqQuery, "1=1", "1=1", Captions.HeaderLinqQuery, Position.Top) { ViewType = ViewType.ListView, View = "Customer_ListView_EmployeesLinq_Linq" };
     yield return new XpandNavigationItemAttribute(Captions.Miscellaneous + "LinqQuery", "Customer_ListView_EmployeesLinq_Linq");
     yield return new CloneViewAttribute(CloneViewType.ListView, "LinqQuery_ListView");
 }

 public override IEnumerable<Attribute> GetAttributes(ITypeInfo typesInfo) {
     if (typesInfo.Type != typeof(Customer)) yield break;
     const string viewId = "Customer_DetailView";
     yield return new XpandNavigationItemAttribute("Navigation/Detail View of Persistent object with records", viewId);
     yield return new AdditionalViewControlsRuleAttribute(Captions.ViewMessage + " " + Captions.HeaderDetailViewNavigation, "1=1", "1=1", Captions.ViewMessageDetailViewNavigation, Position.Bottom) { View = viewId };
     yield return new AdditionalViewControlsRuleAttribute(Captions.Header + " " + Captions.HeaderDetailViewNavigation, "1=1", "1=1", Captions.HeaderDetailViewNavigation, Position.Top) { View = viewId };
 }

 public override IEnumerable<Attribute> GetAttributes(ITypeInfo typesInfo) {
     if (!(typesInfo.Type == typeof (PersistentAssemblyInfo))) yield break;
     yield return new CloneViewAttribute(CloneViewType.DetailView, Quartz_DetailView);
     yield return new XpandNavigationItemAttribute("WorldCreator/Quartz/Quartz AssemblyInfo", Quartz_DetailView) { ObjectKey = CriteriaOperator.Parse("Name=?", "Quartz").ToString() };
     yield return new AdditionalViewControlsRuleAttribute(Captions.ViewMessage + " " + Captions.HeaderQuartz, "1=1", "1=1", Captions.ViewMessageQuartz, Position.Bottom) { View = Quartz_DetailView };
     yield return new AdditionalViewControlsRuleAttribute(Captions.Header + " " + Captions.HeaderQuartz, "1=1", "1=1", Captions.HeaderQuartz, Position.Top) { View = Quartz_DetailView };
 }

		public VsixTestCollection (ITestAssembly testAssembly, ITypeInfo collectionDefinition, 
			string visualStudioVersion, string rootSuffix)
			: base (testAssembly, collectionDefinition, visualStudioVersion + " (" + rootSuffix + ")")
		{
			VisualStudioVersion = visualStudioVersion;
			RootSuffix = rootSuffix;
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="DocumentedType" /> class.
        /// </summary>
        /// <param name="info">The type information.</param>
        /// <param name="properties">The type's properties.</param>
        /// <param name="methods">The type's methods.</param>
        /// <param name="fields">The type's fields.</param>
        /// <param name="summary">The summary.</param>
        /// <param name="remarks">The remarks.</param>
        /// <param name="examples">The examples.</param>
        /// <param name="metadata">The type metadata.</param>
        public DocumentedType(
            ITypeInfo info,
            IEnumerable<DocumentedProperty> properties,
            IEnumerable<DocumentedMethod> methods,
            IEnumerable<DocumentedField> fields,
            SummaryComment summary,
            RemarksComment remarks,
            IEnumerable<ExampleComment> examples,
            IDocumentationMetadata metadata)
            : base(MemberClassification.Type, summary, remarks, examples, metadata)
        {
            Definition = info.Definition;
            TypeClassification = info.Definition.GetTypeClassification();
            Identity = info.Identity;
            Properties = new List<DocumentedProperty>(properties);
            Fields = new List<DocumentedField>(fields);

            // Materialize all methods.
            var documentedMethods = methods as DocumentedMethod[] ?? methods.ToArray();

            Constructors = new List<DocumentedMethod>(GetConstructors(documentedMethods));
            Methods = new List<DocumentedMethod>(GetMethods(documentedMethods));
            Operators = new List<DocumentedMethod>(GetOperators(documentedMethods));

            _extensionMethods = new List<DocumentedMethod>();
        }

        public CulturedXunitTestCase(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, string culture)
            : base(testCollection, assembly, type, method, factAttribute)
        {
            this.culture = culture;

            Traits.Add("Culture", culture);
        }

 public ViewInfo(string viewId, bool isDetailView, bool isRoot, ITypeInfo objectTypeInfo, ViewEditMode? viewEditMode) {
     ViewId = viewId;
     IsDetailView = isDetailView;
     IsRoot = isRoot;
     ObjectTypeInfo = objectTypeInfo;
     ViewEditMode = viewEditMode;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="TestFixture"/> class.
 /// </summary>
 /// <param name="fixtureType">Type of the fixture.</param>
 public TestFixture(ITypeInfo fixtureType) : base(fixtureType)
 {
     CheckSetUpTearDownMethods(typeof(OneTimeSetUpAttribute));
     CheckSetUpTearDownMethods(typeof(OneTimeTearDownAttribute));
     CheckSetUpTearDownMethods(typeof(SetUpAttribute));
     CheckSetUpTearDownMethods(typeof(TearDownAttribute));
 }

 /// <inheritdoc />
 protected override PatternTest CreateTest(PatternEvaluationScope constainingScope, ITypeInfo type)
 {
     PatternTest test = base.CreateTest(constainingScope, type);
     test.Name = NameSanitizer.MakeNameFromIdentifier(test.Name);
     test.Kind = NBehaveTestKinds.Concern;
     return test;
 }

 public override IEnumerable<Attribute> GetAttributes(ITypeInfo typesInfo) {
     if (typesInfo.Type != typeof(ExceptionHandlingObject)) yield break;
     yield return new AdditionalViewControlsRuleAttribute(Captions.ViewMessage + " " + Captions.HeaderExceptionHandling, "1=1", "1=1", Captions.ViewMessageExceptionHandling, Position.Bottom) { ViewType = ViewType.DetailView, View = "ExceptionHandling_DetailView" };
     yield return new AdditionalViewControlsRuleAttribute(Captions.Header + " " + Captions.HeaderExceptionHandling, "1=1", "1=1", Captions.HeaderExceptionHandling, Position.Top) { View = "ExceptionHandling_DetailView" };
     yield return new CloneViewAttribute(CloneViewType.DetailView, "ExceptionHandling_DetailView");
     yield return new XpandNavigationItemAttribute(Captions.Miscellaneous + "ExceptionHandling", "ExceptionHandling_DetailView");
 }

        public ExcelImportWizard(ObjectSpace objectSpace, ITypeInfo typeInfo, CollectionSourceBase collectionSourceBase) {
            //set local variable values
            if (objectSpace == null)
                throw new ArgumentNullException("objectSpace", @"ObjectSpace cannot be NULL");

            ObjectSpace = objectSpace;

            CurrentCollectionSource = collectionSourceBase;
            //_ImportUOW = new UnitOfWork(((ObjectSpace)ObjectSpace).Session.DataLayer);
            Type = typeInfo.Type;
            //this.typeInfo = typeInfo;

            InitializeComponent();
            ImportMapLookUp.Properties.DataSource = ImportMapsCollection.ToList();
            //ImportMapLookUp.Properties.DisplayMember = "Name";
            //disable next, until file and other info is selected
            wizardPage1.AllowNext = false;



            gridLookUpEdit1.Properties.View.OptionsBehavior.AutoPopulateColumns = true;
            gridLookUpEdit1.Properties.DataSource = MappableColumns;//.ToList();
            // gridLookUpEdit1.Properties.SearchMode = SearchMode.OnlyInPopup;
            var col = gridLookUpEdit2View.Columns.ColumnByFieldName("Mapped");
            if (col != null) {
                col.Visible = false;
                col.FilterInfo =
                    new ColumnFilterInfo(new BinaryOperator("Mapped", false));
            }

            col = gridLookUpEdit2View.Columns.ColumnByFieldName("Oid");
            if (col != null)
                col.Visible = false;
        }

 public void AfterTypeEmit(IEmitter emitter, ITypeInfo type)
 {
     foreach (var plugin in this.Parts)
     {
         plugin.AfterTypeEmit(emitter, type);
     }
 }

        /// <summary>
        /// Gets the default value for a reflected type.
        /// </summary>
        /// <param name="type">The reflected type.</param>
        /// <returns>The default value for the type, such as <c>0</c> if
        /// the type represents an integer, or <c>null</c> if the type
        /// is a reference type or if <paramref name="type"/> was null.</returns>
        public static object GetDefaultValue(ITypeInfo type)
        {
            if (type == null)
                return null;

            return ReflectionUtils.GetDefaultValue(type.TypeCode);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="XunitTestCollection"/> class.
 /// </summary>
 public XunitTestCollection(ITestAssembly testAssembly, ITypeInfo collectionDefinition, string displayName)
 {
     CollectionDefinition = collectionDefinition;
     DisplayName = displayName;
     TestAssembly = testAssembly;
     UniqueID = Guid.NewGuid();
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ConcordionTypeInfoAdapter"/> class.
        /// </summary>
        /// <param name="target">The target.</param>
        public ConcordionTypeInfoAdapter(ITypeInfo target)
        {
            if (target == null)
                throw new ArgumentNullException("target");

            Target = target;
        }

 public override IEnumerable<Attribute> GetAttributes(ITypeInfo typesInfo) {
     if (typesInfo.Type!=typeof(PersistentAssemblyInfo))yield break;
     yield return new CloneViewAttribute(CloneViewType.DetailView, "NorthWind_DetailView");
     yield return new XpandNavigationItemAttribute("WorldCreator/NorthWind/NorthWind AssemblyInfo", "NorthWind_DetailView") { ObjectKey = CriteriaOperator.Parse("Name=?", "NorthWind").ToString() };
     yield return new AdditionalViewControlsRuleAttribute(Captions.ViewMessage + " " + Captions.HeaderNorthWind, "1=1", "1=1", Captions.ViewMessageNorthWind, Position.Bottom) {  View = "NorthWind_DetailView" };
     yield return new AdditionalViewControlsRuleAttribute(Captions.Header + " " + Captions.HeaderNorthWind, "1=1", "1=1", Captions.HeaderNorthWind, Position.Top) { View = "NorthWind_DetailView" };
 }

 public ConstructorBlock(IEmitter emitter, ITypeInfo typeInfo, bool staticBlock)
     : base(emitter, typeInfo.TypeDeclaration)
 {
     this.Emitter = emitter;
     this.TypeInfo = typeInfo;
     this.StaticBlock = staticBlock;
 }