Exemplo n.º 1
0
        public void Quota()
        {
            // Arrange
            PermutationSetup permutation = new PermutationSetup();

            permutation.Add(blockpool_3KB);

            permutation.Add(case_ms);
            permutation.Add(case_decor_ms);
            permutation.Add(case_vfs_ms);
            permutation.Add(case_vfs_2ms);


            // Act & Assert
            foreach (Scenario scenario in permutation.Scenarios)
            {
                using (Run run = scenario.Run().Initialize())
                {
                    IFileSystemDisposable fs   = run.Parameters["Class"] as IFileSystemDisposable;
                    IBlockPool            pool = run.Parameters["BlockPool"] as IBlockPool;
                    fs.CreateDirectory("dir/");

                    using (var s = fs.Open("dir/file", FileMode.Create, FileAccess.ReadWrite, FileShare.None))
                    {
                        Assert.AreEqual(0L, pool.BytesAllocated);

                        s.Write(new byte[1024]);
                        Assert.AreEqual(1024L, pool.BytesAllocated);
                        Assert.AreEqual(2048L, pool.BytesAvailable);
                        Assert.AreEqual(1024L, s.Length);

                        s.Write(new byte[1024]);
                        Assert.AreEqual(2048L, pool.BytesAllocated);
                        Assert.AreEqual(1024L, pool.BytesAvailable);
                        Assert.AreEqual(2048L, s.Length);

                        s.Write(new byte[1024]);
                        Assert.AreEqual(3072L, s.Length);
                        Assert.AreEqual(3072L, pool.BytesAllocated);
                        Assert.AreEqual(0L, pool.BytesAvailable);

                        try
                        {
                            s.Write(new byte[1024]);
                            Assert.Fail();
                        }
                        catch (FileSystemExceptionOutOfDiskSpace)
                        {
                        }
                        Assert.AreEqual(3072, s.Length);

                        try
                        {
                            s.WriteByte(3);
                            Assert.Fail();
                        }
                        catch (FileSystemExceptionOutOfDiskSpace)
                        {
                        }
                        Assert.AreEqual(3072, s.Length);

                        s.SetLength(3071);
                        Assert.AreEqual(3071, s.Length);

                        s.WriteByte(3);
                        Assert.AreEqual(3072, s.Length);

                        s.SetLength(0L);
                        Assert.AreEqual(0, s.Length);
                        Assert.AreEqual(0L, pool.BytesAllocated);
                        Assert.AreEqual(3072L, pool.BytesAvailable);

                        s.Write(new byte[1024]);
                        s.Write(new byte[1024]);
                        s.Write(new byte[1024]);
                        Assert.AreEqual(3072L, s.Length);
                        Assert.AreEqual(3072L, pool.BytesAllocated);
                        Assert.AreEqual(0L, pool.BytesAvailable);
                    }

                    Assert.AreEqual(3072L, pool.BytesAllocated);
                    Assert.AreEqual(0L, pool.BytesAvailable);
                    fs.Delete("dir/", true);
                    Assert.AreEqual(0L, pool.BytesAllocated);
                    Assert.AreEqual(3072L, pool.BytesAvailable);


                    fs.CreateFile("newfile", new byte[3072]);
                    Assert.AreEqual(3072L, pool.BytesAllocated);
                    Assert.AreEqual(0L, pool.BytesAvailable);
                    Stream ss = fs.Open("newfile", FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
                    fs.Delete("newfile");
                    Assert.AreEqual(3072L, pool.BytesAllocated);
                    Assert.AreEqual(0L, pool.BytesAvailable);
                    ss.Dispose();
                    Assert.AreEqual(0L, pool.BytesAllocated);
                    Assert.AreEqual(3072L, pool.BytesAvailable);

                    fs.CreateFile("newfile", new byte[3072]);
                    Assert.AreEqual(3072L, pool.BytesAllocated);
                    Assert.AreEqual(0L, pool.BytesAvailable);
                    fs.Dispose();
                    Assert.AreEqual(0L, pool.BytesAllocated);
                    Assert.AreEqual(3072L, pool.BytesAvailable);
                }
            }
        }
        public static void Main(string[] args)
        {
            {
                #region Snippet_1a
                IFileSystem ram = new MemoryFileSystem();
                IFileSystem rom = ram.Decorate(Option.ReadOnly);
                #endregion Snippet_1a
            }
            {
                IFileSystem ram = new MemoryFileSystem();
                #region Snippet_1b
                IFileSystem rom = ram.AsReadOnly();
                #endregion Snippet_1b
            }
            {
                IFileSystem ram = new MemoryFileSystem();
                #region Snippet_2a
                IFileSystem invisible = ram.Decorate(Option.NoOpen);
                #endregion Snippet_2a
            }
            {
                IFileSystem ram = new MemoryFileSystem();
                #region Snippet_2b
                IFileSystem invisible = ram.Decorate(Option.NoBrowse);
                #endregion Snippet_2b
            }
            {
                #region Snippet_3
                IFileSystem ram = new MemoryFileSystem();
                ram.CreateDirectory("tmp/dir/");
                ram.CreateFile("tmp/dir/file.txt", new byte[] { 32, 32, 32, 32, 32, 32, 32, 32, 32 });

                IFileSystem tmp = ram.Decorate(Option.SubPath("tmp/"));
                tmp.PrintTo(Console.Out, format: PrintTree.Format.DefaultPath);
                #endregion Snippet_3
            }

            {
                #region Snippet_4a
                MemoryFileSystem      ram = new MemoryFileSystem();
                IFileSystemDisposable rom = ram.Decorate(Option.ReadOnly).AddSourceToBeDisposed();
                // Do work ...
                rom.Dispose();
                #endregion Snippet_4a
            }

            {
                #region Snippet_4b
                MemoryFileSystem ram = new MemoryFileSystem();
                ram.CreateDirectory("tmp/dir/");
                ram.CreateFile("tmp/dir/file.txt", new byte[] { 32, 32, 32, 32, 32, 32, 32, 32, 32 });
                IFileSystemDisposable rom = ram.Decorate(Option.ReadOnly).AddDisposable(ram);
                // Do work ...
                rom.Dispose();
                #endregion Snippet_4b
            }


            {
                #region Snippet_4c
                // Create ram filesystem
                MemoryFileSystem ram = new MemoryFileSystem();
                ram.CreateDirectory("tmp/dir/");
                ram.CreateFile("tmp/dir/file.txt", new byte[] { 32, 32, 32, 32, 32, 32, 32, 32, 32 });

                // Create decorations
                IFileSystemDisposable rom = ram.Decorate(Option.ReadOnly).AddDisposable(ram.BelateDispose());
                IFileSystemDisposable tmp = ram.Decorate(Option.SubPath("tmp/")).AddDisposable(ram.BelateDispose());
                ram.Dispose(); // <- is actually postponed

                // Do work ...

                // Dispose rom1 and tmp, disposes ram as well
                rom.Dispose();
                tmp.Dispose();
                #endregion Snippet_4c
            }
        }
        public static void Main(string[] args)
        {
            {
                #region Snippet_1
                IFileSystem fs = new PhysicalFileProvider(@"C:\Users").ToFileSystem();
                #endregion Snippet_1
            }
            {
                #region Snippet_2
                IFileProvider fp = new PhysicalFileProvider(@"C:\");
                IFileSystem   fs = fp.ToFileSystem(
                    canBrowse: true,
                    canObserve: true,
                    canOpen: true);
                #endregion Snippet_2

                foreach (var line in fs.VisitTree(depth: 2))
                {
                    Console.WriteLine(line);
                }
            }
            {
                #region Snippet_3
                IFileProvider         fp         = new PhysicalFileProvider(@"C:\Users");
                IFileSystemDisposable filesystem = fp.ToFileSystem().AddDisposable(fp);
                #endregion Snippet_3
            }
            {
                #region Snippet_4
                IFileSystemDisposable filesystem = new PhysicalFileProvider(@"C:\Users")
                                                   .ToFileSystem()
                                                   .AddDisposeAction(fs => fs.FileProviderDisposable?.Dispose());
                #endregion Snippet_4
            }
            {
                #region Snippet_5
                using (var fs = new PhysicalFileProvider(@"C:\Users")
                                .ToFileSystem()
                                .AddDisposeAction(f => f.FileProviderDisposable?.Dispose()))
                {
                    fs.Browse("");

                    // Post pone dispose at end of using()
                    IDisposable belateDisposeHandle = fs.BelateDispose();
                    // Start concurrent work
                    Task.Run(() =>
                    {
                        // Do work
                        Thread.Sleep(100);
                        fs.GetEntry("");

                        // Release the belate dispose handle
                        // FileSystem is actually disposed here
                        // provided that the using block has exited
                        // in the main thread.
                        belateDisposeHandle.Dispose();
                    });

                    // using() exists here and starts the dispose fs
                }
                #endregion Snippet_5
            }

            {
                #region Snippet_6
                IFileSystem fs = new PhysicalFileProvider(@"C:\Users").ToFileSystem();
                foreach (var line in fs.VisitTree(depth: 2))
                {
                    Console.WriteLine(line);
                }
                #endregion Snippet_6
            }

            {
                #region Snippet_7
                IFileSystem        fs       = new PhysicalFileProvider(@"C:\Users").ToFileSystem();
                IObserver <IEvent> observer = new Observer();
                using (IDisposable handle = fs.Observe("**", observer))
                {
                }
                #endregion Snippet_7
            }
        }