public void TestTemporaryStorageStream()
        {
            var textFactory = new TextFactoryService();
            var service = new TemporaryStorageServiceFactory.TemporaryStorageService(textFactory);
            var temporaryStorage = service.CreateTemporaryStreamStorage(System.Threading.CancellationToken.None);

            using (var data = SerializableBytes.CreateWritableStream())
            {
                for (int i = 0; i < SharedPools.ByteBufferSize; i++)
                {
                    data.WriteByte((byte)(i % 2));
                }

                data.Position = 0;
                temporaryStorage.WriteStreamAsync(data).Wait();
                using (var result = temporaryStorage.ReadStreamAsync().Result)
                {
                    Assert.Equal(data.Length, result.Length);

                    for (int i = 0; i < SharedPools.ByteBufferSize; i++)
                    {
                        Assert.Equal(i % 2, result.ReadByte());
                    }
                }
            }
        }
        public void TestTemporaryStorageText()
        {
            var textFactory = new TextFactoryService();
            var service = new TemporaryStorageServiceFactory.TemporaryStorageService(textFactory);

            // test normal string
            var text = SourceText.From(new string(' ', 4096) + "public class A {}");
            TestTemporaryStorage(service, text);

            // test empty string
            text = SourceText.From(string.Empty);
            TestTemporaryStorage(service, text);

            // test large string
            text = SourceText.From(new string(' ', 1024 * 1024) + "public class A {}");
            TestTemporaryStorage(service, text);
        }
        public void TestTemporaryTextStorageExceptions()
        {
            var textFactory = new TextFactoryService();
            var service = new TemporaryStorageServiceFactory.TemporaryStorageService(textFactory);
            var storage = service.CreateTemporaryTextStorage(CancellationToken.None);

            // Nothing has been written yet
            Assert.Throws<InvalidOperationException>(() => storage.ReadText());
            Assert.Throws<AggregateException>(() => storage.ReadTextAsync().Result);

            // write a normal string
            var text = SourceText.From(new string(' ', 4096) + "public class A {}");
            storage.WriteTextAsync(text).Wait();

            // Writing multiple times is not allowed
            Assert.Throws<InvalidOperationException>(() => storage.WriteText(text));
            Assert.Throws<AggregateException>(() => storage.WriteTextAsync(text).Wait());
        }
        public void StreamTest3()
        {
            var textFactory = new TextFactoryService();
            var service = new TemporaryStorageServiceFactory.TemporaryStorageService(textFactory);
            var storage = service.CreateTemporaryStreamStorage(CancellationToken.None);

            using (var expected = new MemoryStream())
            {
                var random = new Random(Environment.TickCount);
                for (var i = 0; i < 100; i++)
                {
                    var position = random.Next(10000);
                    expected.Position = position;

                    var value = (byte)(i % byte.MaxValue);
                    expected.WriteByte(value);
                }

                expected.Position = 0;
                storage.WriteStream(expected);

                expected.Position = 0;
                using (var stream = storage.ReadStream())
                {
                    Assert.Equal(expected.Length, stream.Length);

                    for (int i = 0; i < expected.Length; i++)
                    {
                        var value = expected.ReadByte();
                        if (value != 0)
                        {
                            stream.Position = i;
                            Assert.Equal(value, stream.ReadByte());
                        }
                    }
                }
            }
        }
        public void StreamTest2()
        {
            var textFactory = new TextFactoryService();
            var service = new TemporaryStorageServiceFactory.TemporaryStorageService(textFactory);
            var storage = service.CreateTemporaryStreamStorage(CancellationToken.None);

            using (var expected = new MemoryStream())
            {
                for (var i = 0; i < 10000; i++)
                {
                    expected.WriteByte((byte)(i % byte.MaxValue));
                }

                expected.Position = 0;
                storage.WriteStream(expected);

                expected.Position = 0;
                using (var stream = storage.ReadStream())
                {
                    Assert.Equal(expected.Length, stream.Length);

                    int index = 0;
                    int count;
                    var bytes = new byte[1000];

                    while ((count = stream.Read(bytes, 0, bytes.Length)) > 0)
                    {
                        for (var i = 0; i < count; i++)
                        {
                            Assert.Equal((byte)(index % byte.MaxValue), bytes[i]);
                            index++;
                        }
                    }

                    Assert.Equal(index, stream.Length);
                }
            }
        }
        public void StreamTest1()
        {
            var textFactory = new TextFactoryService();
            var service = new TemporaryStorageServiceFactory.TemporaryStorageService(textFactory);
            var storage = service.CreateTemporaryStreamStorage(CancellationToken.None);

            using (var expected = new MemoryStream())
            {
                for (var i = 0; i < 10000; i++)
                {
                    expected.WriteByte((byte)(i % byte.MaxValue));
                }

                expected.Position = 0;
                storage.WriteStream(expected);

                expected.Position = 0;
                using (var stream = storage.ReadStream())
                {
                    Assert.Equal(expected.Length, stream.Length);

                    for (var i = 0; i < expected.Length; i++)
                    {
                        Assert.Equal(expected.ReadByte(), stream.ReadByte());
                    }
                }
            }
        }
        // We want to keep this test around, but not have it disabled/associated with a bug
        // [Fact, Trait(Traits.Feature, Traits.Features.Workspace)]
        public void TestTemporaryStorageScaling()
        {
            // This will churn through 4GB of memory.  It validates that we don't
            // use up our address space in a 32 bit process.
            if (Environment.Is64BitOperatingSystem && !Environment.Is64BitProcess)
            {
                var textFactory = new TextFactoryService();
                var service = new TemporaryStorageServiceFactory.TemporaryStorageService(textFactory);

                using (var data = SerializableBytes.CreateWritableStream())
                {
                    for (int i = 0; i < 1024 * 128; i++)
                    {
                        data.WriteByte(1);
                    }

                    // Create 4GB of memory mapped files
                    int fileCount = (int)((long)4 * 1024 * 1024 * 1024 / data.Length);
                    var storageHandles = new List<ITemporaryStreamStorage>(fileCount);
                    for (int i = 0; i < fileCount; i++)
                    {
                        var s = service.CreateTemporaryStreamStorage(CancellationToken.None);
                        storageHandles.Add(s);
                        data.Position = 0;
                        s.WriteStreamAsync(data).Wait();
                    }

                    for (int i = 0; i < 1024 * 5; i++)
                    {
                        using (var s = storageHandles[i].ReadStreamAsync().Result)
                        {
                            Assert.Equal(1, s.ReadByte());
                            storageHandles[i].Dispose();
                        }
                    }
                }
            }
        }
        public void TestTemporaryStorageMemoryMappedFileManagement()
        {
            var textFactory = new TextFactoryService();
            var service = new TemporaryStorageServiceFactory.TemporaryStorageService(textFactory);
            var buffer = new MemoryStream(257 * 1024 + 1);
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer.WriteByte((byte)i);
            }

            // Do a relatively cheap concurrent stress test of the backing MemoryMappedFile management
            var tasks = Enumerable.Range(1, 257).Select(async i =>
            {
                for (int j = 1; j < 5; j++)
                {
                    using (ITemporaryStreamStorage storage1 = service.CreateTemporaryStreamStorage(CancellationToken.None),
                        storage2 = service.CreateTemporaryStreamStorage(CancellationToken.None))
                    {
                        var storage3 = service.CreateTemporaryStreamStorage(CancellationToken.None); // let the finalizer run for this instance

                        storage1.WriteStream(new MemoryStream(buffer.GetBuffer(), 0, 1024 * i - 1));
                        storage2.WriteStream(new MemoryStream(buffer.GetBuffer(), 0, 1024 * i));
                        storage3.WriteStream(new MemoryStream(buffer.GetBuffer(), 0, 1024 * i + 1));

                        await Task.Yield();

                        using (Stream s1 = storage1.ReadStream(),
                            s2 = storage2.ReadStream(),
                            s3 = storage3.ReadStream())
                        {
                            Assert.Equal(1024 * i - 1, s1.Length);
                            Assert.Equal(1024 * i, s2.Length);
                            Assert.Equal(1024 * i + 1, s3.Length);
                        }
                    }
                }
            });

            Task.WaitAll(tasks.ToArray());
            GC.Collect(2);
            GC.WaitForPendingFinalizers();
            GC.Collect(2);
        }
        public void TestTemporaryStreamStorageExceptions()
        {
            var textFactory = new TextFactoryService();
            var service = new TemporaryStorageServiceFactory.TemporaryStorageService(textFactory);
            var storage = service.CreateTemporaryStreamStorage(CancellationToken.None);

            // Nothing has been written yet
            Assert.Throws<InvalidOperationException>(() => storage.ReadStream());
            Assert.Throws<AggregateException>(() => storage.ReadStreamAsync().Result);

            // 0 length streams are not allowed
            var stream = new MemoryStream();
            Assert.Throws<ArgumentOutOfRangeException>(() => storage.WriteStream(stream));
            Assert.Throws<AggregateException>(() => storage.WriteStreamAsync(stream).Wait());

            // write a normal stream
            stream.Write(new byte[] { 42 }, 0, 1);
            stream.Position = 0;
            storage.WriteStreamAsync(stream).Wait();

            // Writing multiple times is not allowed
            Assert.Throws<InvalidOperationException>(() => storage.WriteStream(null));
            Assert.Throws<AggregateException>(() => storage.WriteStreamAsync(null).Wait());
        }