Esempio n. 1
0
        private static void TestVirtualDriveCopyDirectory()
        {
            string filename00 = VirtualDrive.VirtualFileName(@"Testdir0\testfile0.bin");
            string filename01 = VirtualDrive.VirtualFileName(@"Testdir0\testfile1.bin");

            string filename10 = VirtualDrive.VirtualFileName(@"Testdir1\testfile0.bin");
            string filename11 = VirtualDrive.VirtualFileName(@"Testdir1\testfile1.bin");

            VirtualDrive.Store(filename00, null);
            VirtualDrive.Store(filename01, null);

            UnitTest.Test(VirtualDrive.ExistsFile(filename00));
            UnitTest.Test(VirtualDrive.ExistsFile(filename01));
            UnitTest.Test(VirtualDrive.ExistsDirectory(
                              VirtualDrive.VirtualFileName("Testdir0")));

            VirtualDrive.CopyDirectory(
                VirtualDrive.VirtualFileName("Testdir0"),
                VirtualDrive.VirtualFileName("Testdir1"));

            UnitTest.Test(VirtualDrive.ExistsFile(filename00));
            UnitTest.Test(VirtualDrive.ExistsFile(filename01));
            UnitTest.Test(VirtualDrive.ExistsDirectory(
                              VirtualDrive.VirtualFileName("Testdir0")));
            UnitTest.Test(VirtualDrive.ExistsFile(filename10));
            UnitTest.Test(VirtualDrive.ExistsFile(filename11));
            UnitTest.Test(VirtualDrive.ExistsDirectory(
                              VirtualDrive.VirtualFileName("Testdir1")));

            VirtualDrive.DeleteDirectory(VirtualDrive.VirtualFileName("Testdir0"), true);
            VirtualDrive.DeleteDirectory(VirtualDrive.VirtualFileName("Testdir1"), true);
        }
Esempio n. 2
0
        public void Clear()
        {
            CheckIsValid();

            foreach (var fileName in recycledToSrc.Keys)
            {
                if (VirtualDrive.ExistsDirectory(fileName))
                {
                    try
                    {
                        VirtualDrive.DeleteDirectory(fileName, true);
                    }
                    catch (Exception)
                    {
                    }
                }
                else if (VirtualDrive.ExistsFile(fileName))
                {
                    VirtualDrive.DeleteFile(fileName);
                }
            }

            recycledToSrc.Clear();
            srcToRecycled.Clear();
        }
Esempio n. 3
0
        public void MoveToRecycleBin(string id)
        {
            CheckIsValid();

            string src = id;
            string dst;

            if (VirtualDrive.ExistsDirectory(id))
            {
                dst = Path.Combine(RootDir, RecycleBinNameDir());
                SafeOperations.MoveDirectory(src, dst);
            }
            else if (VirtualDrive.ExistsFile(id))
            {
                dst = Path.Combine(RootDir, RecycleBinNameFile());
                VirtualDrive.MoveFile(src, dst);
            }
            else
            {
                throw new Exception("\"" + id + "\" does not exist!");
            }

            recycledToSrc[dst] = src;
            srcToRecycled[src] = dst;
        }
Esempio n. 4
0
 private void CheckIsValid()
 {
     if (String.IsNullOrEmpty(RootDir))
     {
         throw new Exception("Recycle bin requires a root directory!");
     }
     if (!VirtualDrive.ExistsDirectory(RootDir))
     {
         throw new Exception("Recycle bin root directory does not exist: \""
                             + RootDir + "\"");
     }
 }
Esempio n. 5
0
        private static void TestVirtualDriveExistsDirectory()
        {
            UnitTest.Test(VirtualDrive.ExistsDirectory(
                              VirtualDrive.VirtualFileName("TestID3VirtualDrive")));
            UnitTest.Test(!VirtualDrive.ExistsDirectory(
                              VirtualDrive.VirtualFileName("ARandomPath")));

            string folder   = VirtualDrive.VirtualFileName("folder");
            string fileName = Path.Combine(folder, "t00.bin");

            VirtualDrive.Store(fileName, null);
            UnitTest.Test(VirtualDrive.ExistsDirectory(folder));
            UnitTest.Test(!VirtualDrive.ExistsDirectory(fileName));
            VirtualDrive.DeleteFile(fileName);
        }
Esempio n. 6
0
        private static void TestVirtualDriveDeleteDirectory()
        {
            VirtualDrive.Store(
                VirtualDrive.VirtualFileName(@"Testdir0\testfile0.bin"),
                null);
            VirtualDrive.Store(
                VirtualDrive.VirtualFileName(@"Testdir0\testfile1.bin"),
                null);

            UnitTest.Test(VirtualDrive.ExistsDirectory(
                              VirtualDrive.VirtualFileName("Testdir0")));

            VirtualDrive.DeleteDirectory(
                VirtualDrive.VirtualFileName("Testdir0"), true);

            UnitTest.Test(!VirtualDrive.ExistsDirectory(
                              VirtualDrive.VirtualFileName("Testdir0")));
        }
Esempio n. 7
0
        public void Restore(string id)
        {
            CheckIsValid();

            string recycled = srcToRecycled[id];
            string src      = id;

            if (VirtualDrive.ExistsDirectory(recycled))
            {
                SafeOperations.MoveDirectory(recycled, src);
            }
            else if (VirtualDrive.ExistsFile(recycled))
            {
                VirtualDrive.MoveFile(recycled, src);
            }
            else
            {
                throw new Exception("\"" + id + "\" not found!");
            }

            recycledToSrc.Remove(recycled);
            srcToRecycled.Remove(src);
        }
Esempio n. 8
0
        private static void Walk(string dirOrFile, List <string> files, List <string> dirs)
        {
            if (VirtualDrive.ExistsFile(dirOrFile))
            {
                files.Add(dirOrFile);
            }
            else if (VirtualDrive.ExistsDirectory(dirOrFile))
            {
                foreach (var item in VirtualDrive.GetDirectories(dirOrFile))
                {
                    Walk(item, files, dirs);
                }
                foreach (var item in VirtualDrive.GetFiles(dirOrFile, "*.*"))
                {
                    Walk(item, files, dirs);
                }

                dirs.Add(dirOrFile);
            }
            else
            {
                throw new Exception("Unknown");
            }
        }
Esempio n. 9
0
        private static void TestAccessObserverMoveDir()
        {
            bool didOpenCalledBack  = false;
            bool didCloseCalledBack = false;

            string folder0   = VirtualDrive.VirtualFileName("myFolder0");
            string folder1   = VirtualDrive.VirtualFileName("myFolder1");
            string fileName0 = VirtualDrive.VirtualFileName(@"myFolder0\myFile0.bin");
            string fileName1 = VirtualDrive.VirtualFileName(@"myFolder0\myFile1.bin");

            VirtualDrive.Store(fileName0, new byte[] { });
            VirtualDrive.Store(fileName1, new byte[] { });

            UnitTest.Test(VirtualDrive.ExistsDirectory(folder0));

            EventHandler <AccessObserver.AccessObserverEventArgs> freeHandler =
                delegate(object sender, AccessObserver.AccessObserverEventArgs args)
            {
                UnitTest.Test(args.AffectedId == folder0);
                UnitTest.Test(args.ObservedId == fileName0);
                UnitTest.Test(args.NewObservedId == VirtualDrive.VirtualFileName(@"myFolder1\myFile0.bin"));
                UnitTest.Test(args.Type == AccessObserver.AccessType.Move);
                UnitTest.Test(args.Request == AccessObserver.AccessRequest.FreeShared);

                didCloseCalledBack = true;

                VirtualDrive.ObserverFreeShared.Unregister(fileName0);
                UnitTest.Test(VirtualDrive.ObserverFreeShared.CountObservedIds == 0);
            };

            EventHandler <AccessObserver.AccessObserverEventArgs> lockHandler =
                delegate(object sender, AccessObserver.AccessObserverEventArgs args)
            {
                UnitTest.Test(args.AffectedId == folder0);
                UnitTest.Test(args.ObservedId == fileName0);
                UnitTest.Test(args.NewObservedId == fileName0);
                UnitTest.Test(args.Type == AccessObserver.AccessType.Move);
                UnitTest.Test(args.Request == AccessObserver.AccessRequest.LockExclusive);

                didOpenCalledBack = true;

                VirtualDrive.ObserverLockExclusive.Unregister(fileName0);
                UnitTest.Test(VirtualDrive.ObserverLockExclusive.CountObservedIds == 0);

                VirtualDrive.ObserverFreeShared.Register(fileName0, freeHandler);
            };

            VirtualDrive.ObserverLockExclusive.Register(fileName0, lockHandler);


            UnitTest.Test(!didOpenCalledBack);
            UnitTest.Test(!didCloseCalledBack);
            VirtualDrive.MoveDirectory(folder0, folder1);
            UnitTest.Test(didOpenCalledBack);
            UnitTest.Test(didCloseCalledBack);

            UnitTest.Test(VirtualDrive.ExistsDirectory(folder1));

            VirtualDrive.DeleteDirectory(VirtualDrive.VirtualFileName(folder1), true);

            UnitTest.Test(!VirtualDrive.ExistsDirectory(folder0));
            UnitTest.Test(!VirtualDrive.ExistsDirectory(folder1));
        }