private void DispatchSendingProfilingDataAction(Stream byteStream)
        {
            var streamLength       = byteStream.DeserializeUint32();
            var profilingDataBytes = new byte[streamLength];

            byteStream.Read(profilingDataBytes, 0, profilingDataBytes.Length);

            List <TCallTree> callTrees;

            using (var profilingDataStream = new MemoryStream(profilingDataBytes))
            {
                _metadataDeserializer.DeserializeAllMetadataAndCacheIt(profilingDataStream);

                callTrees = new List <TCallTree>();
                while (profilingDataStream.Position < profilingDataStream.Length)
                {
                    TCallTree callTree = _callTreeFactory.GetCallTree(profilingDataStream, _methodCache);
                    callTrees.Add(callTree);
                }
            }

            var eventArgs = new ProfilingDataUpdateEventArgs <TCallTree>
            {
                Action       = Actions.SendingProfilingData,
                ProfilerType = _profilerType,
                CallTrees    = callTrees
            };

            ThreadPool.QueueUserWorkItem(notUsed => _updateCallback(this, eventArgs));
        }
        public void EmptyDataTest()
        {
            var metadataDeserializer = new MetadataDeserializer(
                _methodCache,
                _classCache,
                _moduleCache,
                _assemblyCache,
                _srcLocatorMockupFkt);

            metadataDeserializer.DeserializeAllMetadataAndCacheIt(_empty.ConvertToMemoryStream());

            Assert.AreEqual(0, _methodCache.Cache.Count);
            Assert.AreEqual(0, _classCache.Cache.Count);
            Assert.AreEqual(0, _moduleCache.Cache.Count);
            Assert.AreEqual(0, _assemblyCache.Cache.Count);
        }
        public void SetUp()
        {
            _memoryStream  = _metadataBytes.ConvertToMemoryStream();
            _methodCache   = new MetadataCache <MethodMetadata>();
            _classCache    = new MetadataCache <ClassMetadata>();
            _moduleCache   = new MetadataCache <ModuleMetadata>();
            _assemblyCache = new MetadataCache <AssemblyMetadata>();


            var mockSourceLocatorFaktory = new Mock <ISourceLocatorFactory>(MockBehavior.Strict);
            var metadataDeserializer     = new MetadataDeserializer(
                _methodCache,
                _classCache,
                _moduleCache,
                _assemblyCache,
                mockSourceLocatorFaktory.Object);

            metadataDeserializer.DeserializeAllMetadataAndCacheIt(_memoryStream);
        }
        public void EmptyDataWithOffsetInStreamTest()
        {
            MemoryStream memoryStream = _emptyWithOffset.ConvertToMemoryStream();
            uint         dummy        = memoryStream.DeserializeUint32();

            var metadataDeserializer = new MetadataDeserializer(
                _methodCache,
                _classCache,
                _moduleCache,
                _assemblyCache,
                _srcLocatorMockupFkt);

            metadataDeserializer.DeserializeAllMetadataAndCacheIt(memoryStream);

            Assert.AreEqual(0, _methodCache.Cache.Count);
            Assert.AreEqual(0, _classCache.Cache.Count);
            Assert.AreEqual(0, _moduleCache.Cache.Count);
            Assert.AreEqual(0, _assemblyCache.Cache.Count);
        }