public async Task TestSolutionSynchronization()
        {
            var code = @"class Test { void Method() { } }";

            using (var workspace = await TestWorkspace.CreateCSharpAsync(code))
            {
                var solution = workspace.CurrentSolution;

                // build checksum
                await solution.State.GetChecksumAsync(CancellationToken.None);

                var map = solution.GetAssetMap();

                var sessionId = 0;
                var storage = new AssetStorage();
                var source = new TestAssetSource(storage, sessionId, map);

                var service = new AssetService(sessionId, storage);
                await service.SynchronizeSolutionAssetsAsync(await solution.State.GetChecksumAsync(CancellationToken.None), CancellationToken.None);

                object data;
                foreach (var kv in map)
                {
                    Assert.True(storage.TryGetAsset(kv.Key, out data));
                }
            }
        }
        public void TestCreation()
        {
            var sessionId = 0;

            var storage = new AssetStorage();
            var source = new TestAssetSource(storage, sessionId);

            var stored = storage.TryGetAssetSource(sessionId);
            Assert.Equal(source, stored);

            storage.UnregisterAssetSource(sessionId);

            var none = storage.TryGetAssetSource(sessionId);
            Assert.Null(none);
        }
        public async Task TestAssets()
        {
            var sessionId = 0;
            var checksum = new Checksum(Guid.NewGuid().ToByteArray());
            var data = new object();

            var storage = new AssetStorage();
            var source = new TestAssetSource(storage, sessionId, checksum, data);

            var service = new AssetService(sessionId, storage);
            var stored = await service.GetAssetAsync<object>(checksum, CancellationToken.None);
            Assert.Equal(data, stored);

            var stored2 = await service.GetAssetsAsync<object>(new[] { checksum }, CancellationToken.None);
            Assert.Equal(1, stored2.Count);

            Assert.Equal(checksum, stored2[0].Item1);
            Assert.Equal(data, stored2[0].Item2);
        }
        private static async Task<SolutionService> GetSolutionServiceAsync(Solution solution, Dictionary<Checksum, object> map = null)
        {
            // make sure checksum is calculated
            await solution.State.GetChecksumAsync(CancellationToken.None);

            map = map ?? new Dictionary<Checksum, object>();
            solution.AppendAssetMap(map);

            var sessionId = 0;
            var storage = new AssetStorage();
            var source = new TestAssetSource(storage, sessionId, map);
            var service = new SolutionService(new AssetService(sessionId, storage));

            return service;
        }