public void setup()
        {
            _provider = new DirectoryVirtualFileProvider();
            _root = MockRepository.GenerateMock<IVirtualDirectory>();

            _provider.Setup(_root);
        }

 public InMemoryVirtualDirectory(IVirtualPathProvider owningProvider, IVirtualDirectory parentDirectory)
     : base(owningProvider, parentDirectory)
 {
     this.files = new List<InMemoryVirtualFile>();
     this.dirs = new List<InMemoryVirtualDirectory>();
     this.DirLastModified = DateTime.MinValue;
 }

        public AzureBlobVirtualFile(AzureBlobVirtualPathProvider owningProvider, IVirtualDirectory directory)
            : base(owningProvider, directory)
        {
            this.pathProvider = owningProvider;
            this.container = pathProvider.Container;

        }

        public string GetTemplatePath(IVirtualDirectory fileDir)
        {
            try
            {
                if (templatePathsNotFound.Contains(fileDir.VirtualPath)) return null;

                var templateDir = fileDir;
                IVirtualFile templateFile;
                while (templateDir != null && templateDir.GetFile(defaultTemplateName) == null)
                {
                    if (templatePathsFound.TryGetValue(templateDir.VirtualPath, out templateFile))
                        return templateFile.RealPath;

                    templateDir = templateDir.ParentDirectory;
                }

                if (templateDir != null)
                {
                    templateFile = templateDir.GetFile(defaultTemplateName);
                    templatePathsFound[templateDir.VirtualPath] = templateFile;
                    return templateFile.VirtualPath;
                }

                templatePathsNotFound.Add(fileDir.VirtualPath);
                return null;

            }
            catch (Exception ex)
            {
                ex.Message.Print();
                throw;
            }
        }

        public FileSystemVirtualDirectory(IVirtualPathProvider owningProvider, IVirtualDirectory parentDirectory, DirectoryInfo dInfo)
            : base(owningProvider, parentDirectory)
        {
            if (dInfo == null)
                throw new ArgumentNullException("dInfo");

            this.BackingDirInfo = dInfo;
        }

        protected AbstractVirtualDirectoryBase(IVirtualPathProvider owningProvider, IVirtualDirectory parentDirectory)
        {
            if (owningProvider == null)
                throw new ArgumentNullException("owningProvider");

            this.VirtualPathProvider = owningProvider;
            this.ParentDirectory = parentDirectory;
        }

        public FileSystemVirtualFile(IVirtualPathProvider owningProvider, IVirtualDirectory directory, FileInfo fInfo) 
            : base(owningProvider, directory)
        {
            if (fInfo == null)
                throw new ArgumentNullException("fInfo");

            this.BackingFile = fInfo;
        }

 public SftpVirtualFile(SftpVirtualPathProvider owningProvider, IVirtualDirectory directory, string name, DateTime? lastModified)
     : base(owningProvider, directory)
 {
     this.Provider = owningProvider;
     this._name = name;
     this._lastModified = lastModified ?? DateTime.MinValue;
     this.File = new Lazy<SftpFile>(() => _file ?? Provider.GetSftpFile(this.VirtualPath));
 }

 public SftpVirtualDirectory(SftpVirtualPathProvider owningProvider, IVirtualDirectory parentDirectory, 
     String name = null, DateTime? lastModified = null)
     : base(owningProvider, parentDirectory)
 {
     this.Provider = owningProvider;
     _name = name;
     _lastModified = lastModified ?? DateTime.MinValue;
 }

 public ResourceVirtualDirectory(IVirtualPathProvider owningProvider, 
     IVirtualDirectory parentDir, 
     Assembly backingAsm, 
     string rootNamespace)
 : this(owningProvider, 
     parentDir, 
     backingAsm, 
     rootNamespace,
     rootNamespace, 
     GetResourceNames(backingAsm, rootNamespace)) { }

        private int[] getCounts(IVirtualDirectory subroot, int[] subRoots)
        {
            var index = subroot.GetFile("Index.xml");
            XmlSerializer ser = new XmlSerializer(typeof(Root));
            var o = ser.Deserialize(index.Open());
            var root =  o as Root;

            if (subRoots == null || subRoots.Length == 0)
                subRoots = Enumerable.Range(0, root.Groups).ToArray();

            return subRoots;
        }

        protected AbstractVirtualFileBase(
            IVirtualPathProvider owningProvider, IVirtualDirectory directory)
        {
            if (owningProvider == null)
                throw new ArgumentNullException("owningProvider");

            if (directory == null)
                throw new ArgumentNullException("directory");

            this.VirtualPathProvider = owningProvider;
            this.Directory = directory;
        }

 protected override IVirtualFile CopyBackingFileToDirectory(IVirtualDirectory directory, string name)
 {
     if (directory is FileSystemVirtualDirectory)
     {
         var copyFInfo = BackingFile.CopyTo(Path.Combine(directory.RealPath, name), true);
         return new FileSystemVirtualFile(VirtualPathProvider, directory, copyFInfo);
     }
     else
     {
         return directory.CopyFile(this, name);
     }
 }

 protected override IVirtualFile MoveBackingFileToDirectory(IVirtualDirectory directory, string name)
 {
     if (directory is FileSystemVirtualDirectory)
     {
         BackingFile.MoveTo(Path.Combine(directory.RealPath, name));
         return new FileSystemVirtualFile(VirtualPathProvider, directory, BackingFile);
     }
     else
     {
         var newFile = directory.CopyFile(this, name);
         this.Delete();
         return newFile;
     }
 }

        public ResourceVirtualDirectory(IVirtualPathProvider owningProvider, IVirtualDirectory parentDir, Assembly backingAsm, String directoryName, IEnumerable<String> manifestResourceNames)
            : base(owningProvider, parentDir)
        {
            if (backingAsm == null)
                throw new ArgumentNullException("backingAsm");

            if (string.IsNullOrEmpty(directoryName))
                throw new ArgumentException("directoryName");

            this.backingAssembly = backingAsm;
            this.DirectoryName = directoryName;

            InitializeDirectoryStructure(manifestResourceNames);
        }

        protected override IVirtualFile CopyBackingFileToDirectory(IVirtualDirectory directory, string name)
        {
            if (directory is DropboxVirtualDirectory)
            {
                var dir = (DropboxVirtualDirectory)directory;
                if (dir.Provider == this.Provider)
                {
                    Provider.Copy(this.VirtualPath, Provider.CombineVirtualPath(directory.VirtualPath, name));
                    return new DropboxVirtualFile(Provider, dir, name);
                }
            }

            // TODO: copy cross Dropboxes using CopyRef?

            return directory.CopyFile(this, name);
        }

        protected override IVirtualFile MoveBackingFileToDirectory(IVirtualDirectory directory, string name)
        {
            if (directory is SftpVirtualDirectory)
            {
                var dir = (SftpVirtualDirectory)directory;
                if (dir.Provider == this.Provider)
                {
                    ((SftpVirtualDirectory)this.Directory).RemoveFromCache(this);
                    File.Value.MoveTo(Provider.CombineVirtualPath(directory.VirtualPath, name));
                    return new SftpVirtualFile(Provider, dir, name, DateTime.Now);
                }
            }

            var newFile = directory.CopyFile(this, name);
            this.Delete();
            return newFile;
        }

        protected override IVirtualFile MoveBackingFileToDirectory(IVirtualDirectory directory, string name)
        {
            if (directory is FtpVirtualDirectory)
            {
                var dir = (FtpVirtualDirectory)directory;
                if (dir.Provider == this.Provider)
                {
                    var currentDir = (FtpVirtualDirectory)this.Directory;
                    currentDir.RemoveFromContents(this.Name);
                    Provider.Rename(this.VirtualPath, Provider.CombineVirtualPath(dir.VirtualPath, name));
                    return new FtpVirtualFile(Provider, dir, name, DateTime.Now);
                }
            }

            var newFile = directory.CopyFile(this, name);
            this.Delete();
            return newFile;
        }

        public ResourceVirtualDirectory(IVirtualPathProvider owningProvider, 
            IVirtualDirectory parentDir, 
            Assembly backingAsm, 
            string rootNamespace, 
            string directoryName, 
            List<string> manifestResourceNames)
            : base(owningProvider, parentDir)
        {
            if (backingAsm == null)
                throw new ArgumentNullException(nameof(backingAsm));

            if (string.IsNullOrEmpty(directoryName))
                throw new ArgumentNullException(nameof(directoryName));

            this.backingAssembly = backingAsm;
            this.rootNamespace = rootNamespace;
            this.DirectoryName = directoryName;

            InitializeDirectoryStructure(manifestResourceNames);
        }

        public Dictionary<int, IVirtualFile> BuildVirtualFiles(IVirtualDirectory root, string name, int[] subRoots)
        {
            var subrootDir = root.GetDirectory(name);
            subRoots = getCounts(subrootDir, subRoots);

            XmlSerializer ser = new XmlSerializer(typeof(Group));
            var dict = new Dictionary<int, IVirtualFile>();
            foreach (var subroot in subRoots)
            {
                var fs = subrootDir.GetFile(subroot + ".xml").Open();
                if (fs == null) continue;

                var group = ser.Deserialize(fs) as Group;
                if (group == null) continue;

                foreach (var item in group.Source.Items)
                {
                    dict.Add(item.ID, item);
                }
            }
            return dict;
        }