C# UnitTestElementConsumer类代码示例

        public void ExploreAssembly(IProject project, IMetadataAssembly assembly, UnitTestElementConsumer consumer, ManualResetEvent exitEvent)
        {
            var envoy = ProjectModelElementEnvoy.Create(project);
            if (assembly.ReferencedAssembliesNames.Any(n => n.Name == SilverlightMsTestAssemblyName))
            {
                var allElements = new List<IUnitTestElement>();
                var mappedElements = new Dictionary<IUnitTestElement, IUnitTestElement>();

                new mstestlegacy::JetBrains.ReSharper.UnitTestProvider.MSTest.MsTestMetadataExplorer(msTestElementFactory, msTestAttributesProvider, project, shellLocks, allElements.Add)
                    .ExploreAssembly(assembly);

                foreach (var classElement in allElements.OfType<mstest10::JetBrains.ReSharper.UnitTestProvider.MSTest10.MsTestTestClassElement>())
                    mappedElements.Add(classElement, elementFactory.GetOrCreateClassElement(classElement.TypeName, project, envoy));

                foreach (var methodElement in allElements.OfType<mstest10::JetBrains.ReSharper.UnitTestProvider.MSTest10.MsTestTestMethodElement>())
                    mappedElements.Add(methodElement, elementFactory.GetOrCreateMethodElement(methodElement.Id, project, (mstestlegacy::JetBrains.ReSharper.UnitTestProvider.MSTest.MsTestTestClassElementBase)mappedElements[methodElement.Parent], envoy, methodElement.TypeName));

                foreach (var rowElement in allElements.OfType<mstest10::JetBrains.ReSharper.UnitTestProvider.MSTest10.MsTestTestRowElement>())
                    mappedElements.Add(rowElement, elementFactory.GetOrCreateRowElement(rowElement.Id, project, (mstestlegacy::JetBrains.ReSharper.UnitTestProvider.MSTest.MsTestTestMethodElementBase)mappedElements[rowElement.Parent], envoy));

                foreach (var element in allElements)
                {
                    IUnitTestElement mappedElement;
                    if (mappedElements.TryGetValue(element, out mappedElement))
                        consumer(mappedElements[element]);
                    else
                        consumer(element);
                }

            }
        }

 private void AddStoriesToProject(IProject project, UnitTestElementConsumer consumer, StorEvilProjectElement projectElement, IEnumerable<Story> stories)
 {
     foreach (Story story in stories)
     {
         AddStoryElement(story, project, consumer, projectElement);
     }
 }

    public AssemblyExplorer(MSpecUnitTestProvider provider,
#if RESHARPER_61
                            IUnitTestElementManager manager,
                            PsiModuleManager psiModuleManager,
                            CacheManager cacheManager,
#endif
                            IMetadataAssembly assembly,
                            IProject project,
                            UnitTestElementConsumer consumer)
    {
      _assembly = assembly;
      _consumer = consumer;

      using (ReadLockCookie.Create())
      {
        var projectEnvoy = new ProjectModelElementEnvoy(project);

        var cache = new ContextCache();
#if RESHARPER_61
        _contextFactory = new ContextFactory(provider, manager, psiModuleManager, cacheManager, project, projectEnvoy, _assembly.Location.FullPath, cache);
        _contextSpecificationFactory = new ContextSpecificationFactory(provider, manager, psiModuleManager, cacheManager, project, projectEnvoy, cache);
        _behaviorFactory = new BehaviorFactory(provider, manager, psiModuleManager, cacheManager, project, projectEnvoy, cache);
        _behaviorSpecificationFactory = new BehaviorSpecificationFactory(provider, manager, psiModuleManager, cacheManager, project, projectEnvoy);
#else
#if RESHARPER_6
        _contextFactory = new ContextFactory(provider, project, projectEnvoy, _assembly.Location.FullPath, cache);
#else
        _contextFactory = new ContextFactory(provider, project, projectEnvoy, _assembly.Location, cache);
#endif
        _contextSpecificationFactory = new ContextSpecificationFactory(provider, project, projectEnvoy, cache);
        _behaviorFactory = new BehaviorFactory(provider, project, projectEnvoy, cache);
        _behaviorSpecificationFactory = new BehaviorSpecificationFactory(provider, project, projectEnvoy);
#endif
      }
    }

    public void Explore(IProject project, IMetadataAssembly assembly, UnitTestElementConsumer consumer, IMetadataTypeInfo metadataTypeInfo)
    {
      if (!metadataTypeInfo.IsContext())
      {
        return;
      }

      var contextElement = _factories.Contexts.CreateContext(project, assembly.Location.FullPath, metadataTypeInfo);

      consumer(contextElement);

      metadataTypeInfo.GetSpecifications()
          .ForEach(x => consumer(_factories.ContextSpecifications.CreateContextSpecification(contextElement, x)));


      metadataTypeInfo.GetBehaviors().ForEach(x =>
      {
        var behaviorElement = _factories.Behaviors.CreateBehavior(contextElement, x);
        consumer(behaviorElement);


        _factories.BehaviorSpecifications
                    .CreateBehaviorSpecificationsFromBehavior(behaviorElement, x)
                    .ForEach(y => consumer(y));
      });
    }

    public void Explore(IProject project, IMetadataAssembly assembly, UnitTestElementConsumer consumer)
    {
      if (!assembly.ReferencedAssembliesNames.Any(x => String.Equals(
                                                                     x.Name,
                                                                     typeof(It).Assembly.GetName().Name,
                                                                     StringComparison.InvariantCultureIgnoreCase)))
      {
        return;
      }

      assembly.GetTypes().Where(type => type.IsContext()).ForEach(type =>
      {
        var contextElement = _factories.Contexts.CreateContext(project,assembly.Location.FullPath, type);
        consumer(contextElement);

        type
          .GetSpecifications()
          .ForEach(x => consumer(_factories.ContextSpecifications.CreateContextSpecification(contextElement, x)));

        type.GetBehaviors().ForEach(x =>
        {
          var behaviorElement = _factories.Behaviors.CreateBehavior(contextElement, x);
          consumer(behaviorElement);

          _factories.BehaviorSpecifications
                    .CreateBehaviorSpecificationsFromBehavior(behaviorElement, x)
                    .ForEach(y => consumer(y));
        });
      });
    }

 public void ExploreAssembly(IProject project,
                             IMetadataAssembly assembly,
                             UnitTestElementConsumer consumer,
                             ManualResetEvent exitEvent)
 {
   ExploreAssembly(project, assembly, consumer);
 }

    public void ExploreAssembly(IProject project, IMetadataAssembly assembly, UnitTestElementConsumer consumer)
    {
      new AssemblyExplorer(_provider,
#if RESHARPER_61
        _manager, _psiModuleManager, _cacheManager, 
#endif
        assembly, project, consumer).Explore();
    }

 public MetadataExplorer(IUnitTestProvider provider, ISolution solution, IProject project, UnitTestElementConsumer consumer)
 {
     testProvider = provider;
     this.consumer = consumer;
     this.project = project;
     this.solution = solution;
     projectModel = new ProjectModelElementEnvoy(this.project);
 }

 public void ExploreAssembly(IProject project, IMetadataAssembly assembly, UnitTestElementConsumer consumer)
 {
   using (ReadLockCookie.Create()) //Get a read lock so that it is safe to read the assembly
   {
     foreach (var metadataTypeInfo in GetTypesIncludingNested(assembly.GetTypes()))
       this._assemblyExplorer.Explore(project, assembly, consumer, metadataTypeInfo);
   }
 }

 // ReSharper 8.0
 public void ExploreAssembly(IProject project, IMetadataAssembly assembly, UnitTestElementConsumer consumer, ManualResetEvent exitEvent)
 {
     // TODO: Monitor exitEvent to stop processing. Note that nunit currently ignores it, too
     using (ReadLockCookie.Create())
     {
         foreach (var metadataTypeInfo in GetExportedTypes(assembly.GetTypes()))
             ExploreType(project, assembly, consumer, metadataTypeInfo);
     }
 }

        public void ExploreAssembly(IProject project, IMetadataAssembly assembly, UnitTestElementConsumer consumer)
        {
            var types = GetExportedTypes(assembly.GetTypes()).ToArray();

            foreach (var metadataTypeInfo in types)
            {
                ExploreType(project, assembly, consumer, metadataTypeInfo);
            }
        }

 private void AddScenarioElement(IProject project, UnitTestElementConsumer consumer,
     StorEvilStoryElement storyElement, IScenario scenario)
 {
     if (scenario is Scenario)
         consumer(new StorEvilScenarioElement(_provider, storyElement, project, scenario.Name, (Scenario)scenario));
     else
         consumer(new StorEvilScenarioOutlineElement(_provider, storyElement, project, scenario.Name,
                                                     (ScenarioOutline)scenario));
 }

 public XunitMetadataExplorer([NotNull] XunitElementFactory factory, IShellLocks shellLocks, IProject project, UnitTestElementConsumer consumer)
 {
     if (factory == null) throw new ArgumentNullException("factory");
     this.project = project;
     this.consumer = consumer;
     this.shellLocks = shellLocks;
     this.factory = factory;
     envoy = ProjectModelElementEnvoy.Create(project);
 }

        private void AddStoryElement(Story story, IProject project,
            UnitTestElementConsumer consumer, StorEvilProjectElement parent)
        {
            var storyElement = GetStoryElement(parent, project, story);
            consumer(storyElement);

            foreach (IScenario scenario in story.Scenarios)
                AddScenarioElement(project, consumer, storyElement, scenario);
        }

 private void ExploreType(IProject project, IMetadataAssembly assembly, UnitTestElementConsumer consumer, IMetadataTypeInfo metadataTypeInfo)
 {
     // It would be nice to use TestClassCommandFactory.Make(...), but that doesn't work
     // with RunWith, since Make ends up calling TypeUtility.GetRunWith, which tries to
     // call IAttributeInfo.GetInstance<RunWithAttribute>, and we can't support that.
     // So we'll break down Make and do it ourselves. If the runner finds any methods
     // that we don't find, it will create them at runtime
     var typeInfo = metadataTypeInfo.AsTypeInfo();
     if (TypeUtility.IsTestClass(typeInfo))
         ExploreTestClass(project, assembly, consumer, typeInfo, metadataTypeInfo.FullyQualifiedName);
 }