public void SetUp()
		{
			IKernel kernel = new StandardKernel();
			var refRepository = Substitute.For<IReferenceRepository>();
			refRepository.GetRoles().ReturnsForAnyArgs(new List<Role>() {
        new Role() { DisplayName = "Appraiser", Id = 1 },
        new Role() { DisplayName = "Appraisal Company Admin", Id = 2 },
        new Role() { DisplayName = "DVS Super Admin", Id = 3 },
        new Role() { DisplayName = "DVS Admin", Id = 4 },
        new Role() { DisplayName = "Company Admin and Appraiser", Id = 5 }
      });
			refRepository.GetRole(RoleType.AppraisalCompanyAdmin).Returns(new Role() { DisplayName = "Appraisal Company Admin", Id = 2 });
			refRepository.GetRole(RoleType.DvsAdmin).Returns(new Role() { DisplayName = "DVS Admin", Id = 4 });

			kernel.Bind<IReferenceRepository>().ToConstant(refRepository);
			kernel.Bind<IReferenceManagement>().To<ReferenceManagement>().InSingletonScope();
			kernel.Bind<ICacheService>().To<FakeCacheService>();
			Singletones.NinjectKernel = kernel;
			_userManager = Substitute.For<IUsersManagement>();
			_appraiserService = Substitute.For<IAppraiserUserService>();
			_companyService = Substitute.For<IAppraisalCompanyService>();
			_taskManager = Substitute.For<ITaskManager>();
			_testOrderManager = Substitute.For<ITestOrderManager>();
			//_geocodingValidation = new GeocodingZIPValidation(Substitute.For<IGeocodingDataService>());
			//_geocodingValidation.ValidateAddress(new ValidateAddressArg()).ReturnsForAnyArgs(new ValidateAddressResult { IsValid = true });
			_geocodingValidation = new FakeGeocodingZIPValidation();

			_target = new AppraiserUserAddController(_userManager, _appraiserService, _companyService, _taskManager, _testOrderManager, _geocodingValidation);
			_target.SecurityContext = Substitute.For<ISecurityContext>();
			_target.SecurityContext.CurrentUser.Returns(new User() { Id = 1, Roles = new Role[] { new Role() { Id = (int)RoleType.DvsAdmin } } });
		}

 public TeacherTaskController(ITaskManager taskManager, ISubjectManager subjectManager, ITypeOfTaskManager typeOfTaskManager, IGroupManager groupManager)
 {
     this._taskManager = taskManager;
     this._subjectManager = subjectManager;
     this._typeOfTaskManager = typeOfTaskManager;
     this._groupManager = groupManager;
 }

 public AutomaticRestartEntryPoint(IServerApplicationHost appHost, ILogger logger, ITaskManager iTaskManager, ISessionManager sessionManager)
 {
     _appHost = appHost;
     _logger = logger;
     _iTaskManager = iTaskManager;
     _sessionManager = sessionManager;
 }

		public AppraiserProfileController
				(
				IAppraiserUserService appraiserUserService,
				IAscGovLicenseService ascGovLicenseService,
				IUsersManagement usersManager,
				IReferenceManagement referenceManagement,
				IDVSUserManager dvsUsersManager,
				IAppraiserManagement appraiserManager,
				IAppraiserAccessManager appraiserAccessManager,
				IHUDService hudService,
				IUserAccessHelper userAccessHelper,
				IGeocodingValidation geocodingValidation,
				ITestOrderManager testOrderManager,
				ITaskManager taskManager
				)
		{
			_appraiserUserService = ValidationUtil.CheckOnNullAndThrowIfNull(appraiserUserService);
			_ascGovLicenseService = ValidationUtil.CheckOnNullAndThrowIfNull(ascGovLicenseService);
			_usersManager = ValidationUtil.CheckOnNullAndThrowIfNull(usersManager);
			_referenceManagement = ValidationUtil.CheckOnNullAndThrowIfNull(referenceManagement);
			_appraiserManager = ValidationUtil.CheckOnNullAndThrowIfNull(appraiserManager);
			_dvsUsersManager = ValidationUtil.CheckOnNullAndThrowIfNull(dvsUsersManager);
			_appraiserAccessManager = ValidationUtil.CheckOnNullAndThrowIfNull(appraiserAccessManager);
			_hudService = ValidationUtil.CheckOnNullAndThrowIfNull(hudService);
			_userAccessHelper = ValidationUtil.CheckOnNullAndThrowIfNull(userAccessHelper);
			_geocodingValidation = geocodingValidation;
			_testOrderManager = ValidationUtil.CheckOnNullAndThrowIfNull(testOrderManager);
			_taskManager = ValidationUtil.CheckOnNullAndThrowIfNull(taskManager);
		}

		public AppraisalCompanyAddController(IAppraisalCompanySignUpService appraisalCompanySignUpService,
			ITaskManager taskManager, IGeocodingValidation geocodingValidation)
		{
			_appraisalCompanySignUpService = ValidationUtil.CheckOnNullAndThrowIfNull(appraisalCompanySignUpService);
			_taskManager = ValidationUtil.CheckOnNullAndThrowIfNull(taskManager);
			_geocodingValidation = ValidationUtil.CheckOnNullAndThrowIfNull(geocodingValidation);
		}

        public void InitializeAsync(CancellationTokenSource cancellationTokenSource,
                                    ITaskManager taskManager,
                                    IHttpDownloaderContainer httpDownloaderContainer,
                                    IErrorFeedback errorFeedback,
                                    IProxySearchFeedback proxySearchFeedback,
                                    IGeoIP geoIP)
        {
            this.httpDownloaderContainer = httpDownloaderContainer;
            TaskItem taskItem = taskManager.Create(Resources.ConfigureProviderOfProxyDetails);

            taskItem.UpdateDetails(Resources.DetermineCurrentIPAddress);

            initializatinTask = httpDownloaderContainer.HttpDownloader
                                                       .GetContentOrNull(MyIPUrl, null, cancellationTokenSource)
                                                       .ContinueWith(task =>
                                                       {
                                                           try
                                                           {
                                                               if (task.Result != null)
                                                               {
                                                                   IPAddress.TryParse(task.Result.Trim(), out myIPAddress);
                                                               }
                                                           }
                                                           finally
                                                           {
                                                               taskItem.Dispose();
                                                           }
                                                       });
        }

 public HubManager(ILogger<HubManager> logger, ITaskManager taskManager)
 {
     this.taskManager = taskManager;
     this.taskManager.AddMessageHandler(this.SendMessage);
     //this.taskManager.OnMessage = this.SendMessage;
     this.logger = logger;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ScheduledTaskWorker" /> class.
        /// </summary>
        /// <param name="scheduledTask">The scheduled task.</param>
        /// <param name="applicationPaths">The application paths.</param>
        /// <param name="taskManager">The task manager.</param>
        /// <param name="jsonSerializer">The json serializer.</param>
        /// <param name="logger">The logger.</param>
        /// <exception cref="System.ArgumentNullException">
        /// scheduledTask
        /// or
        /// applicationPaths
        /// or
        /// taskManager
        /// or
        /// jsonSerializer
        /// or
        /// logger
        /// </exception>
        public ScheduledTaskWorker(IScheduledTask scheduledTask, IApplicationPaths applicationPaths, ITaskManager taskManager, IJsonSerializer jsonSerializer, ILogger logger, IFileSystem fileSystem)
        {
            if (scheduledTask == null)
            {
                throw new ArgumentNullException("scheduledTask");
            }
            if (applicationPaths == null)
            {
                throw new ArgumentNullException("applicationPaths");
            }
            if (taskManager == null)
            {
                throw new ArgumentNullException("taskManager");
            }
            if (jsonSerializer == null)
            {
                throw new ArgumentNullException("jsonSerializer");
            }
            if (logger == null)
            {
                throw new ArgumentNullException("logger");
            }

            ScheduledTask = scheduledTask;
            ApplicationPaths = applicationPaths;
            TaskManager = taskManager;
            JsonSerializer = jsonSerializer;
            Logger = logger;
            _fileSystem = fileSystem;

            InitTriggerEvents();
        }

		public AppraisalCompanyWizardController(IAppraisalCompanyService appraisalCompanyService, IAppraiserManagement appraiserManagement, ITaskManager taskManager, IGeocodingValidation geocodingValidation)
		{
			_appraisalCompanyService = appraisalCompanyService;
			_appraiserManagement = appraiserManagement;
			_taskManager = taskManager;
			_geocodingValidation = geocodingValidation;
		}

 public void SetUp()
 {
     taskManager = MockRepository.GenerateStub<ITaskManager>();
     fileSystem = MockRepository.GenerateStub<IFileSystem>();
     var exceptionPolicy = MockRepository.GenerateStub<IUnhandledExceptionPolicy>();
     var eventAggregator = MockRepository.GenerateStub<IEventAggregator>();
     controller = new CopyController(taskManager, fileSystem, exceptionPolicy, eventAggregator);
 }

		public ProjectReloadPackage(IProjectController projectController, IWindowManager windowManager, 
			ICommandFactory commandFactory, ITaskManager taskManager)
		{
			this.projectController = projectController;
			this.windowManager = windowManager;
			this.commandFactory = commandFactory;
			this.taskManager = taskManager;
		}

		public AppraiserManagement(IUserRepository userRepository, IAppraiserUserRepository appraiserUserRepository, IReferenceManagement refManager, ITaskManager taskManager, IAscGovLicenseService ascLicenseService)
		{
			_userRepository = userRepository;
			_appraiserUserRepository = appraiserUserRepository;
			_refManager = refManager;
			_taskManager = taskManager;
			_ascLicenseService = ascLicenseService;
		}

 public Notifications(IInstallationManager installationManager, INotificationsRepository notificationsRepo, IUserManager userManager, ILogger logger, ITaskManager taskManager)
 {
     _installationManager = installationManager;
     _notificationsRepo = notificationsRepo;
     _userManager = userManager;
     _logger = logger;
     _taskManager = taskManager;
 }

		public AvmRequestsService(IConfigurationHelper configurationHelper, ICommitProvider commitProvider, IAvmRequestsRepository avmRequestsRepository, ITaskManager taskManager, IOrderManager orderManager, IDocumentService documentService)
		{
			_configurationHelper = configurationHelper;
			_commitProvider = commitProvider;
			_avmRequestsRepository = avmRequestsRepository;
			_taskManager = taskManager;
			_orderManager = orderManager;
			_documentService = documentService;
		}

		public HomeController(IUsersManagement userManagement,
			IAuthProvider authenticationProvider, IUserAccessHelper userAccessHelper, IAppraiserManagement appraiserManagement, ITaskManager taskManager)
		{
			_userManagement = userManagement;
			_authenticationProvider = authenticationProvider;
			_userAccessHelper = userAccessHelper;
			_appraiserManagement = appraiserManagement;
			_taskManager = taskManager;
		}

		public void SetUp()
		{
			projectController = MockRepository.GenerateStub<IProjectController>();
			windowManager = MockRepository.GenerateStub<IWindowManager>();
			commandFactory = MockRepository.GenerateStub<ICommandFactory>();
			taskManager = MockRepository.GenerateStub<ITaskManager>();		

			package = new ProjectReloadPackage(projectController, windowManager, commandFactory, taskManager);
		}

 public AutomaticRestartEntryPoint(IServerApplicationHost appHost, ILogger logger, ITaskManager iTaskManager, ISessionManager sessionManager, IServerConfigurationManager config, ILiveTvManager liveTvManager)
 {
     _appHost = appHost;
     _logger = logger;
     _iTaskManager = iTaskManager;
     _sessionManager = sessionManager;
     _config = config;
     _liveTvManager = liveTvManager;
 }

        public ProjectExplorerPackage(IWindowManager windowManager, IProjectController projectController, IReportController reportController, 
			ITaskManager taskManager, ICommandFactory commandFactory)
        {
        	this.windowManager = windowManager;
        	this.projectController = projectController;
        	this.reportController = reportController;
        	this.taskManager = taskManager;
        	this.commandFactory = commandFactory;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ServerEntryPoint" /> class.
        /// </summary>
        /// <param name="taskManager">The task manager.</param>
        /// <param name="appPaths">The app paths.</param>
        /// <param name="logManager"></param>
        public ServerEntryPoint(ITaskManager taskManager, ILibraryManager libraryManager, IApplicationPaths appPaths, ILogManager logManager, ISecurityManager securityManager)
        {
            _taskManager = taskManager;
            LibraryManager = libraryManager;
            PluginSecurityManager = securityManager;
            Plugin.Logger = logManager.GetLogger(Plugin.Instance.Name);

            Instance = this;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="WebSocketEvents" /> class.
 /// </summary>
 /// <param name="serverManager">The server manager.</param>
 /// <param name="logger">The logger.</param>
 /// <param name="userManager">The user manager.</param>
 public WebSocketEvents(IServerManager serverManager, IServerApplicationHost appHost, ILogger logger, IUserManager userManager, IInstallationManager installationManager, ITaskManager taskManager)
 {
     _serverManager = serverManager;
     _logger = logger;
     _userManager = userManager;
     _installationManager = installationManager;
     _appHost = appHost;
     _taskManager = taskManager;
 }