public TestCollectionService(IConfigurationService configurationService, IFileService fileService, ICommandService commandService, IManifestService manifestService)
 {
     _configurationService = configurationService;
     _fileService = fileService;
     _commandService = commandService;
     _manifestService = manifestService;
 }

        /// <summary>
        /// Get the canonical volume root (e.g. the \\?\VolumeGuid format) for the given path. The path must not be relative.
        /// </summary>
        /// <exception cref="ArgumentException">Thrown if the path is relative or indeterminate.</exception>
        /// <exception cref="System.IO.IOException">Thrown if unable to get the root from the OS.</exception>
        public static string GetCanonicalRoot(this IExtendedFileService extendedFileService, IFileService fileService, string path)
        {
            if (Paths.IsRelative(path)) throw new ArgumentException();

            path = fileService.GetFullPath(path);
            int rootLength;
            var format = Paths.GetPathFormat(path, out rootLength);
            if (format == PathFormat.UnknownFormat) throw new ArgumentException();

            string root = path.Substring(0, rootLength);
            string simpleRoot = root;
            string canonicalRoot = root;

            switch (format)
            {
                case PathFormat.UniformNamingConventionExtended:
                    simpleRoot = @"\\" + root.Substring(Paths.ExtendedUncPrefix.Length);
                    goto case PathFormat.UniformNamingConvention;
                case PathFormat.UniformNamingConvention:
                    canonicalRoot = simpleRoot;
                    break;
                case PathFormat.VolumeAbsoluteExtended:
                case PathFormat.DriveAbsolute:
                    canonicalRoot = extendedFileService.GetVolumeName(root);
                    simpleRoot = extendedFileService.GetMountPoint(root);
                    break;
            }

            return canonicalRoot;
        }

        /// <inheritdoc />
        protected override ProjectTemplateResult CreateProjectCore(IFileService fileService, FilePath filePath)
        {
            var project = (NetProject)ProjectDescriptor.GetDescriptorByExtension(filePath.Extension).CreateProject(filePath.FileName);

            project.ApplicationType = ApplicationType;
            project.FilePath = filePath;

            var results = new List<TemplateResult>();

            foreach (var file in Files)
            {
                var result = file.CreateFile(
                    fileService,
                    project,
                    new FilePath(project.ProjectDirectory, file.Name + Language.StandardFileExtension));

                foreach (var createdFile in result.CreatedFiles)
                {
                    project.ProjectFiles.Add(new ProjectFileEntry(createdFile.File as OpenedFile));
                }

                results.Add(result);
            }

            foreach (var reference in References)
                project.References.Add(reference);

            return new ProjectTemplateResult(project, results.ToArray());
        }

 protected ClientSettingsView(string settingsSection, SettingsLocation settingsLocation, IConfigurationManager configurationManager, IFileService fileService)
 {
     ConfigurationManager = configurationManager;
     FileService = fileService;
     SettingsSection = settingsSection;
     SettingsLocation = settingsLocation;
 }

        public static JadeCore.Project.IProject Read(string path, IFileService fileService)
        {
            ProjectType xml;
            XmlSerializer serializer = new XmlSerializer(typeof(ProjectType));
            TextReader tr = new StreamReader(path);
            try
            {
                xml = (ProjectType)serializer.Deserialize(tr);
            }
            finally
            {
                tr.Close();
                tr.Dispose();
            }

            JadeCore.Project.IProject result = new JadeCore.Project.Project(xml.Name, FilePath.Make(path));

            foreach (FolderType f in xml.Folders)
            {
                result.AddFolder(MakeFolder(result, result.Directory, f, fileService));
            }
            foreach (FileType f in xml.Files)
            {
                result.AddItem(null, MakeFile(result.Directory, f, fileService));
            }
            return result;
        }

        public ChatController(IUserService userservice, IChatRoomService chatService, IMessageService messageService, IFileService fileService)
        {
            UserService = userservice;
            ChatService = chatService;
            MessageService = messageService;
            FileService = fileService;
            config = new MapperConfiguration(cfg =>
            {
                cfg.CreateMap<User, UserChatViewModel>()
                .ForMember(dest => dest.UserFoto,
                            opt => opt.MapFrom(src => src.UserFoto.
                                                       Insert(src.UserFoto.LastIndexOf('/') + 1,
                                                       "mini/")));
                cfg.CreateMap<ChatRoom, ChatRoomPartialViewModel>();

                cfg.CreateMap<Message, MessageViewModels>()
                .ForMember(dest => dest.UserName, opt => opt.MapFrom(src => src.User.UserName))
                .ForMember(dest => dest.PathFotoUser,
                            opt => opt.MapFrom(src => src.User.UserFoto.
                                                       Insert(src.User.UserFoto.LastIndexOf('/') + 1,
                                                       "mini/")))
                .ForMember(dest => dest.FileId,
                            opt => opt.MapFrom(src => src.File.Id))
                .ForMember(dest => dest.FileName,
                            opt => opt.MapFrom(src => src.File.NameFile));
                cfg.CreateMap<ChatRoom, ChatRoomViewModels>()
                .ForMember(dest => dest.UserName, opt => opt.MapFrom(src => src.User.UserName))
                .ForMember(dest => dest.Users, opt => opt.MapFrom(src => src.Users))
                .ForMember(dest => dest.Messages, opt => opt.MapFrom(src => src.Messages));
            });
        }

 /// <summary>
 /// DownloadsModule constructor.
 /// </summary>
 /// <param name="fileService">FileService dependency.</param>
 /// <param name="sessionManager">NHibernate session manager dependency.</param>
 public DownloadsModule(IFileService fileService,IFileResourceService fileResourceService, ISessionManager sessionManager, IContentItemService<FileResource> contentItemService)
 {
     this._sessionManager = sessionManager;
     this._fileService = fileService;
     this._contentItemService = contentItemService;
     this._fileResourceService = fileResourceService;
 }

        public BuildArgumentParser(string taskName, string[] targets, string options, IFileService fileService)
            : base (fileService)
        {
            this.AddTarget(taskName);
            if (targets != null)
            {
                foreach (string target in targets)
                    this.AddTarget(target);
            }

            if (String.IsNullOrWhiteSpace(options)) { return; }

            // Options are in xml format <Option>value</Option> or <Option/> for default
            XmlReaderSettings settings = new XmlReaderSettings
            {
                ConformanceLevel = ConformanceLevel.Fragment
            };

            using (XmlReader reader = XmlReader.Create(new StringReader(options), settings))
            {
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        this.AddOrUpdateOption(
                            optionName: reader.Name,
                            optionValue: reader.ReadString());
                    }
                }
            }
        }

 /// <summary>
 /// Constructor.
 /// </summary>
 public Install()
 {
     this._commonDao = IoC.Resolve<ICommonDao>();
     this._siteService = IoC.Resolve<ISiteService>();
     this._moduleLoader = IoC.Resolve<ModuleLoader>();
     this._fileService = IoC.Resolve<IFileService>();
 }

 public NetkanTransformer(
     IHttpService http,
     IFileService fileService,
     IModuleService moduleService,
     string githubToken,
     bool prerelease
 )
 {
     _transformers = InjectVersionedOverrideTransformers(new List<ITransformer>
     {
         new MetaNetkanTransformer(http),
         new SpacedockTransformer(new SpacedockApi(http)),
         new GithubTransformer(new GithubApi(githubToken), prerelease),
         new HttpTransformer(),
         new JenkinsTransformer(http),
         new InternalCkanTransformer(http, moduleService),
         new AvcTransformer(http, moduleService),
         new VersionEditTransformer(),
         new ForcedVTransformer(),
         new EpochTransformer(),
         // This is the "default" VersionedOverrideTransformer for compatability with overrides that don't
         // specify a before or after property.
         new VersionedOverrideTransformer(before: new string[] { null }, after: new string[] { null }),
         new DownloadAttributeTransformer(http, fileService),
         new GeneratedByTransformer(),
         new OptimusPrimeTransformer(),
         new StripNetkanMetadataTransformer(),
         new PropertySortTransformer()
     });
 }

 public DataManagementController(ICategoryService categoryService, IDataItemService dataItemService, IMemberService memberService, IFileService fileService)
 {
     this.categoryService = categoryService;
     this.dataItemService = dataItemService;
     this.memberService = memberService;
     this.fileService = fileService;
 }

 /// <summary>
 /// Initializes a new instance of the MainViewModel class.
 /// </summary>
 public AddPluginViewModel(IZipService zipService, IFileService fileService, ILiveWriterService liveWriterService)
 {
     _zipService = zipService;
     _fileService = fileService;
     _liveWriterService = liveWriterService;
     CanAdd = AppHelper.LiveWriterInstalled;
 }

        static private JadeCore.Project.IProject Read(string name, StreamReader reader, FilePath projectPath, IFileService fileService)
        {
            IProject project = new JadeCore.Project.Project(name, projectPath);

            while (!reader.EndOfStream)
            {
                string line = reader.ReadLine();
                Match match = Regex.Match(line, _compileLineRegex);
                if (match.Success)
                {
                    string itemPath = match.Groups[1].Value;
                    itemPath = JadeUtils.IO.PathUtils.CombinePaths(projectPath.Directory, itemPath);
                    project.AddItem(null, new JadeCore.Project.FileItem(fileService.MakeFileHandle(itemPath)));
                    continue;
                }
                match = Regex.Match(line, _includeLineRegex);
                if (match.Success)
                {
                    string itemPath = match.Groups[1].Value;
                    itemPath = JadeUtils.IO.PathUtils.CombinePaths(projectPath.Directory, itemPath);
                    project.AddItem(null, new JadeCore.Project.FileItem(fileService.MakeFileHandle(itemPath)));
                    continue;
                }
            }            
            return project;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FileModule" /> class.
        /// </summary>
        /// <param name="fileService">The file service.</param>
        public FileModule(IFileService fileService)
        {
            if (fileService == null) throw new ArgumentNullException("fileService");
            _fileService = fileService;

            ListingHtml = ListingTemplate;
        }

        public PackageServiceTestBase()
        {
            _releaseStore = A.Fake<IReleaseStore>(opts => opts.Strict());
            _fileService = A.Fake<IFileService>(opts => opts.Strict());

            _SUT = new PackageService(_releaseStore, _fileService);
        }

        static public JadeCore.Workspace.IWorkspace Read(FilePath path, IFileService fileService)
        {
            WorkspaceType xml;
            XmlSerializer serializer = new XmlSerializer(typeof(WorkspaceType));
            TextReader tr = new StreamReader(path.Str);
            try
            {                
                xml = (WorkspaceType)serializer.Deserialize(tr);                
            }
            finally
            {
                tr.Close();
                tr.Dispose();
            }

            JadeCore.Workspace.IWorkspace result = new JadeCore.Workspace.Workspace(xml.Name, path);
            foreach (FolderType f in xml.Folders)
            {
                result.AddFolder(MakeFolder(result, result.Directory, f, fileService));
            }
            foreach (ProjectType p in xml.Projects)
            {
                result.AddProject(MakeProject(result.Directory, p, fileService));
            }

            return result;
        }

        internal static IEnumerable<IFileSystemInformation> EnumerateChildrenInternal(
            string directory,
            ChildType childType,
            string searchPattern,
            System.IO.SearchOption searchOption,
            FileAttributes excludeAttributes,
            IFileService fileService)
        {
            // We want to be able to see all files as we recurse and open new find handles (that might be over MAX_PATH).
            // We've already normalized our base directory.
            string extendedDirectory = Paths.AddExtendedPrefix(directory);

            // The assertion here is that we want to find files that match the desired pattern in all subdirectories, even if the
            // subdirectories themselves don't match the pattern. That requires two passes to avoid overallocating for directories
            // with a large number of files.

            // First look for items that match the given search pattern in the current directory
            using (FindOperation findOperation = new FindOperation(Paths.Combine(extendedDirectory, searchPattern)))
            {
                FindResult findResult;
                while ((findResult = findOperation.GetNextResult()) != null)
                {
                    bool isDirectory = (findResult.Attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY) == FileAttributes.FILE_ATTRIBUTE_DIRECTORY;

                    if ((findResult.Attributes & excludeAttributes) == 0
                        && findResult.FileName != "."
                        && findResult.FileName != ".."
                        && ((isDirectory && childType == ChildType.Directory)
                            || (!isDirectory && childType == ChildType.File)))
                    {
                        yield return FileSystemInformation.Create(findResult, directory, fileService);
                    }
                }
            }

            if (searchOption != System.IO.SearchOption.AllDirectories) yield break;

            // Now recurse into each subdirectory
            using (FindOperation findOperation = new FindOperation(Paths.Combine(extendedDirectory, "*"), directoriesOnly: true))
            {
                FindResult findResult;
                while ((findResult = findOperation.GetNextResult()) != null)
                {
                    // Unfortunately there is no guarantee that the API will return only directories even if we ask for it
                    bool isDirectory = (findResult.Attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY) == FileAttributes.FILE_ATTRIBUTE_DIRECTORY;

                    if ((findResult.Attributes & excludeAttributes) == 0
                        && isDirectory
                        && findResult.FileName != "."
                        && findResult.FileName != "..")
                    {
                        foreach (var child in EnumerateChildrenInternal(Paths.Combine(directory, findResult.FileName), childType, searchPattern,
                            searchOption, excludeAttributes, fileService))
                        {
                            yield return child;
                        }
                    }
                }
            }
        }

 public MediaSelectorService(ISession session, IFileService fileService, IImageProcessor imageProcessor, Site site)
 {
     _session = session;
     _fileService = fileService;
     _imageProcessor = imageProcessor;
     _site = site;
 }

 public OTAUIController(IOTAUIService otaUIService, IOTARedisService redisService, IFileService fileService, IUserAccessDataControlService userAccessDataControlService, IMembershipService membershipService, IFullTextSearchService fullTextSearchService)
     : base(otaUIService, redisService, fileService, fullTextSearchService)
 {
     this.UserAccessDataControlService = userAccessDataControlService;
     this.MembershipService = membershipService;
     StatusOTAService = StructureMap.ObjectFactory.GetInstance<IStatusOTAService>();
 }

 public SetupEcommerceWidgets(IWidgetService widgetService, IDocumentService documentService, IFormAdminService formAdminService, IFileService fileService)
 {
     _widgetService = widgetService;
     _documentService = documentService;
     _formAdminService = formAdminService;
     _fileService = fileService;
 }