public ContextEntityTypesProvider(IMetadataProvider metadataProvider)
 {
     var testMetadata = metadataProvider.GetMetadataSet<TestCaseMetadataIdentity>().Metadata.Values.OfType<TestCaseMetadataElement>().ToArray();
     var features = GetContextFeatures(testMetadata);
     _entitiesByContext = features.GroupBy(x => x.Context, x => x.Data)
                                  .ToDictionary(x => x.Key, x => x.SelectMany(y => y).Select(y => y.GetType()).Distinct().ToArray());
 }

 public UpdateMetadataCommandTests()
 {
     _metadataProvider = Substitute.For<IMetadataProvider>();
     _progressManager = Substitute.For<IProgressManagerViewModel>();
     _busyProvider = Substitute.For<IBusyProvider>();
     _command = new UpdateMetadataCommand(_metadataProvider, _progressManager, _busyProvider);
 }

    SetRandomMetadata
    (
        IMetadataProvider oMetadataProvider,
        Boolean bSetMetadataValues,
        Boolean bSetTag,
        Int32 iSeed
    )
    {
        KeyValuePair<String, Object> [] aoRandomMetadata;
        Object oRandomTag;

        GetRandomMetadata(iSeed, out aoRandomMetadata, out oRandomTag);

        if (bSetMetadataValues)
        {
            foreach (KeyValuePair<String, Object> oRandomMetadata
                in aoRandomMetadata)
            {
                oMetadataProvider.SetValue(
                    oRandomMetadata.Key, oRandomMetadata.Value);
            }
        }

        if (bSetTag)
        {
            oMetadataProvider.Tag = oRandomTag;
        }
    }

		public PdbWriter(string fileName, IMetadataProvider metadataProvider)
		{
			this.pdb = new ISymUnmanagedWriter2();
			this.metadataProvider = metadataProvider;
			this.documentWriters = new Dictionary<string, ISymUnmanagedDocumentWriter>();

			this.pdb.Initialize(new Metadata(metadataProvider), fileName, pIStream: null, fFullBuild: true);
		}

 /// <summary>
 /// Loads the signature.
 /// </summary>
 /// <param name="provider">The provider.</param>
 /// <param name="token">The token.</param>
 public void LoadSignature(IMetadataProvider provider, TokenTypes token)
 {
     byte[] buffer;
     int index = 0;
     provider.Read(token, out buffer);
     ParseSignature(buffer, ref index);
     Debug.Assert(index == buffer.Length, @"Signature parser didn't complete.");
 }

 public EdmModelBuilder(IMetadataProvider metadataProvider)
 {
     if (metadataProvider == null)
     {
         throw new ArgumentNullException("metadataProvider");
     }
     _metadataProvider = metadataProvider;
 }

        private static IEdmModel BuildModel(IMetadataProvider provider, Uri contextId)
        {
            var builder = new EdmModelBuilder(provider);
            var model = builder.Build(contextId);

            model.Dump();

            return model;
        }

        /// <summary>
        /// Loads the signature.
        /// </summary>
        /// <param name="provider">The provider.</param>
        /// <param name="token">The token.</param>
        public Signature(IMetadataProvider provider, TokenTypes token)
        {
            SignatureReader reader = new SignatureReader(provider.ReadBlob(token));

            this.ParseSignature(reader);
            Debug.Assert(reader.Index == reader.Length, @"Signature parser didn't complete.");

            this.token = token;
        }

 public EventBus(IMessageSender messageSender,
     IRoutingKeyProvider routingKeyProvider,
     IMetadataProvider metadataProvider)
 {
     this.messageSender = messageSender;
     this.routingKeyProvider = routingKeyProvider;
     this.metadataProvider = metadataProvider;
     this.logger = LogManager.GetLogger("ThinkNet");
 }

 /// <summary>
 /// Parses the specified provider.
 /// </summary>
 /// <param name="provider">The provider.</param>
 /// <param name="token">The token.</param>
 /// <returns></returns>
 public static LocalVariableSignature Parse(IMetadataProvider provider, TokenTypes token)
 {
     byte[] buffer;
     int index = 0;
     provider.Read(token, out buffer);
     LocalVariableSignature sig = new LocalVariableSignature();
     sig.ParseSignature(buffer, ref index);
     Debug.Assert(index == buffer.Length, @"Signature parser didn't complete.");
     return sig;
 }

 public OperationsPrimaryProcessingJob(
     IMetadataProvider metadataProvider,
     IMessageFlowProcessorFactory messageFlowProcessorFactory,
     ISignInService signInService,
     IUserImpersonationService userImpersonationService,
     ITracer tracer)
     : base(signInService, userImpersonationService, tracer)
 {
     _metadataProvider = metadataProvider;
     _messageFlowProcessorFactory = messageFlowProcessorFactory;
 }

        public GenerationController(DTE dte, IMetadataProvider metadataProvider, SolutionMonitor solutionMonitor, TemplateController templateController, EventQueue eventQueue)
        {
            this.dte = dte;
            this.metadataProvider = metadataProvider;
            this.templateController = templateController;

            solutionMonitor.FileAdded += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Render, args.Path);
            solutionMonitor.FileChanged += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Render, args.Path);
            solutionMonitor.FileDeleted += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Delete, args.Path);
            solutionMonitor.FileRenamed += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Rename, args.OldPath, args.NewPath);
        }

 public CommandBus(IMessageSender messageSender,
     ICommandResultManager commandResultManager,
     IRoutingKeyProvider routingKeyProvider,
     IMetadataProvider metadataProvider)
 {
     this.messageSender = messageSender;
     this.commandResultManager = commandResultManager;
     this.routingKeyProvider = routingKeyProvider;
     this.metadataProvider = metadataProvider;
     this.logger = LogManager.GetLogger("ThinkNet");
 }

        /// <summary>
        /// Loads the signature.
        /// </summary>
        /// <param name="provider">The provider.</param>
        /// <param name="token">The token.</param>
        public void LoadSignature(ISignatureContext context, IMetadataProvider provider, TokenTypes token)
        {
            byte[] buffer;
            provider.Read(token, out buffer);

            int index = 0;
            this.ParseSignature(context, buffer, ref index);
            Debug.Assert(index == buffer.Length, @"Signature parser didn't complete.");

            this.token = token;
        }

 public OperationsFinalProcessingJob(
     IMetadataProvider metadataProvider,
     IMessageFlowProcessorFactory messageFlowProcessorFactory,
     ISignInService signInService,
     IUserImpersonationService userImpersonationService,
     ITracer tracer)
     : base(signInService, userImpersonationService, tracer)
 {
     _metadataProvider = metadataProvider;
     _messageFlowProcessorFactory = messageFlowProcessorFactory;
     _firstFaultTolerantStageSetting = new Lazy<MessageProcessingStage>(EvaluateFirstFaultTolerantStage);
 }

 public FactsReplicator(
     ITracer tracer,
     IReplicationSettings replicationSettings,
     IMetadataProvider metadataProvider,
     IFactProcessorFactory factProcessorFactory,
     IComparer<Type> factTypePriorityComparer)
 {
     _tracer = tracer;
     _replicationSettings = replicationSettings;
     _metadataProvider = metadataProvider;
     _factProcessorFactory = factProcessorFactory;
     _factTypePriorityComparer = factTypePriorityComparer;
 }

        /// <summary>
        /// Creates an instance of a specific heap type.
        /// </summary>
        /// <param name="provider">The provider buffer, which contains the heap.</param>
        /// <param name="type">The type of the heap to create.</param>
        /// <param name="metadata">The metadata.</param>
        /// <param name="offset">The offset into the buffer, where the heap starts.</param>
        /// <param name="size">The size of the heap in bytes.</param>
        /// <returns>An instance of the requested heap type.</returns>
        /// <exception cref="System.ArgumentException">An invalid heap type was requested.</exception>
        public static Heap CreateHeap(IMetadataProvider provider, HeapType type, byte[] metadata, int offset, int size)
        {
            switch (type)
            {
                case HeapType.String: return new StringHeap(metadata, offset, size);
                case HeapType.Guid: return new GuidHeap(metadata, offset, size);
                case HeapType.Blob: return new BlobHeap(metadata, offset, size);
                case HeapType.UserString: return new UserStringHeap(metadata, offset, size);
                case HeapType.Tables: return new TableHeap(provider, metadata, offset, size);
            }

            throw new ArgumentException(@"Invalid heap type.", @"type");
        }

        public given_an_empty_event_log()
        {
            this.tableName = "AzureEventLogFixture" + new Random((int)DateTime.Now.Ticks).Next();
            var settings = InfrastructureSettings.Read("Settings.xml").EventSourcing;
            this.account = CloudStorageAccount.Parse(settings.ConnectionString);

            this.eventA = new EventA();
            this.eventB = new EventB();
            this.eventC = new EventC();

            this.metadata = Mock.Of<IMetadataProvider>(x =>
                x.GetMetadata(eventA) == new Dictionary<string, string>
                {
                    { StandardMetadata.SourceId, eventA.SourceId.ToString() },
                    { StandardMetadata.SourceType, "SourceA" }, 
                    { StandardMetadata.Kind, StandardMetadata.EventKind },
                    { StandardMetadata.AssemblyName, "A" }, 
                    { StandardMetadata.Namespace, "Namespace" }, 
                    { StandardMetadata.FullName, "Namespace.EventA" }, 
                    { StandardMetadata.TypeName, "EventA" }, 
                } &&
                x.GetMetadata(eventB) == new Dictionary<string, string>
                {
                    { StandardMetadata.SourceId, eventB.SourceId.ToString() },
                    { StandardMetadata.SourceType, "SourceB" }, 
                    { StandardMetadata.Kind, StandardMetadata.EventKind },
                    { StandardMetadata.AssemblyName, "B" }, 
                    { StandardMetadata.Namespace, "Namespace" }, 
                    { StandardMetadata.FullName, "Namespace.EventB" }, 
                    { StandardMetadata.TypeName, "EventB" }, 
                } &&
                x.GetMetadata(eventC) == new Dictionary<string, string>
                {
                    { StandardMetadata.SourceId, eventC.SourceId.ToString() },
                    { StandardMetadata.SourceType, "SourceC" }, 
                    { StandardMetadata.Kind, StandardMetadata.EventKind },
                    { StandardMetadata.AssemblyName, "B" }, 
                    { StandardMetadata.Namespace, "AnotherNamespace" }, 
                    { StandardMetadata.FullName, "AnotherNamespace.EventC" }, 
                    { StandardMetadata.TypeName, "EventC" }, 
                });

            this.serializer = new JsonTextSerializer();
            this.writer = new AzureMessageLogWriter(this.account, this.tableName);
            this.sut = new AzureEventLogReader(this.account, this.tableName, new JsonTextSerializer());

            this.startEnqueueTime = new DateTime(2012, 06, 30, 23, 59, 0, DateTimeKind.Utc);
            Save(eventA, startEnqueueTime);
            Save(eventB, startEnqueueTime.AddMinutes(5));
            Save(eventC, startEnqueueTime.AddMinutes(6));
        }

        //*************************************************************************
        //  Method: CheckRandomMetadata()
        //
        /// <summary>
        /// Checks the random metadata and Tag values on an object that implements
        /// <see cref="IMetadataProvider" />.
        /// </summary>
        ///
        /// <param name="oMetadataProvider">
        /// Object to check random metadata and Tag values on.
        /// </param>
        ///
        /// <param name="bRandomMetadataExpected">
        /// true if the metadata was set with <see cref="SetRandomMetadata" />,
        /// false if the metadata was left empty.
        /// </param>
        ///
        /// <param name="bRandomTagExpected">
        /// true if the Tag was set with <see cref="SetRandomMetadata" />,
        /// false if the Tag was left as null.
        /// </param>
        ///
        /// <param name="iSeed">
        /// Seed to use for the random number generator.
        /// </param>
        ///
        /// <remarks>
        /// This method checks the random metadata and Tag values that were set
        /// with <see cref="SetRandomMetadata" />.
        /// </remarks>
        //*************************************************************************
        public static void CheckRandomMetadata(
            IMetadataProvider oMetadataProvider,
            Boolean bRandomMetadataExpected,
            Boolean bRandomTagExpected,
            Int32 iSeed
            )
        {
            KeyValuePair<String, Object> [] aoRandomMetadata;
            Object oRandomTag;

            GetRandomMetadata(iSeed, out aoRandomMetadata, out oRandomTag);

            foreach (KeyValuePair<String, Object> oRandomMetadata
            in aoRandomMetadata)
            {
            String sRandomKey = oRandomMetadata.Key;
            Object oRandomValue = oRandomMetadata.Value;

            if (bRandomMetadataExpected)
            {
                Assert.IsTrue( oMetadataProvider.ContainsKey(sRandomKey) );

                Object oValue;

                Assert.IsTrue( oMetadataProvider.TryGetValue(

                    sRandomKey,

                    (oRandomValue == null) ?
                        typeof(Object) : oRandomValue.GetType(),

                    out oValue
                    ) );

                CheckMetadataValue(oRandomValue, oValue);
            }
            else
            {
                Assert.IsFalse( oMetadataProvider.ContainsKey(sRandomKey) );
            }
            }

            if (bRandomTagExpected)
            {
            CheckMetadataValue(oRandomTag, oMetadataProvider.Tag);
            }
            else
            {
            Assert.IsNull(oMetadataProvider.Tag);
            }
        }

        public CommonReplicationStrategy(IMetadataProvider metadataProvider, Type entityType)
        {
            Guard.AgainstNull(metadataProvider, "metadataProvider");
            Guard.AgainstNull(entityType, "entityType");
            Guard.AgainstViolation(!entityType.IsNullable() && !entityType.IsArray,
                "CommonReplicationStrategy is not applicable to nullable or array types");

            this.entityType = entityType;

            memberDescriptions = metadataProvider.GetFieldsReplicationInfo(entityType)
                .Where(t => t.Behavior != ReplicationBehavior.Ignore)
                .Select(t => new MemberReplicationInfo(entityType, t))
                .ToArray();
        }