public LanguageInterceptor(IPersister persister, ContentActivator activator, IWebContext context, ILanguageGateway gateway)
 {
     this.persister = persister;
     this.activator = activator;
     this.context = context;
     this.gateway = gateway;
 }

		public ItemXmlReader(IDefinitionManager definitions, ContentActivator activator, IRepository<ContentItem> repository)
		{
			this.definitions = definitions;
			this.activator = activator;
			this.readers = DefaultReaders();
			this.repository = repository;
		}

 public ExternalContentRepository(ContainerRepository<ExternalItem> containerRepository, IPersister persister, ContentActivator activator, EditSection config)
 {
     this.containerRepository = containerRepository;
     this.persister = persister;
     this.activator = activator;
     externalItemType = Type.GetType(config.Externals.ExternalItemType) ?? typeof(ExternalItem);
 }

 public MongoInstallationManager(MongoDatabaseProvider database, IHost host, IPersister persister, ConnectionMonitor connectionContext, Importer importer, IWebContext webContext, ContentActivator activator)
     : base(connectionContext, importer, webContext, persister, activator)
 {
     this.database = database;
     this.host = host;
     this.persister = persister;
 }

		public override void SetUp()
		{
			base.SetUp();

			activator = new ContentActivator(stateChanger = new N2.Edit.Workflow.StateChanger(), notifier = new ItemNotifier(), new InterceptingProxyFactory());
			activator.Initialize(new[] { new ItemDefinition(typeof(Definitions.PersistableItem)), new ItemDefinition(typeof(Definitions.PersistableItem1b)) });
		}

 public void SetUp()
 {
     var changer = new N2.Edit.Workflow.StateChanger();
     var activator = new ContentActivator(changer, MockRepository.GenerateStrictMock<IItemNotifier>(), new EmptyProxyFactory());
     DefinitionBuilder builder = new DefinitionBuilder(new DefinitionMap(), new Fakes.FakeTypeFinder(typeof(RestrictsChildWithCardinality), typeof(ChildWithCardinality)), new TransformerBase<IUniquelyNamed>[0], new EngineSection { Definitions = new DefinitionCollection { DefineUnattributedTypes = true } });
     definitions = new DefinitionManager(new[] { new DefinitionProvider(builder) }, new ITemplateProvider[0], activator, changer);
 }

		public XmlInstallationManager(IHost host, IPersister persister, XmlContentRepository repository, ConnectionMonitor connectionContext, Importer importer, IWebContext webContext, ContentActivator activator)
            : base(connectionContext, importer, webContext, persister, activator)
        {
            this.host = host;
            this.persister = persister;
			this.repository = repository;
        }

        public override void SetUp()
        {
            base.SetUp();

            finder = new FakeTypeFinder(typeof(XmlableItem).Assembly, typeof(XmlableItem), typeof(XmlableItem2));
            notifier = mocks.Stub<IItemNotifier>();
            mocks.Replay(notifier);

            activator = new ContentActivator(new N2.Edit.Workflow.StateChanger(), notifier, new InterceptingProxyFactory());
            definitions = new DefinitionManager(
                new[] {new DefinitionProvider(new DefinitionBuilder(new DefinitionMap(), 
                    finder, 
                    new TransformerBase<IUniquelyNamed>[0],
                    TestSupport.SetupEngineSection()))}, 
                activator, new StateChanger(), new DefinitionMap());
            definitions.Start();
            parser = mocks.StrictMock<IUrlParser>();
            Expect.On(parser)
                .Call(parser.BuildUrl(null))
                .IgnoreArguments()
                .Do(new BuildUrl(delegate(ContentItem itemToBuild)
                                    {
                                        string url = "/" + itemToBuild.Name + ".aspx";
                                        foreach (ContentItem parent in Find.EnumerateParents(itemToBuild, null))
                                        {
                                            if (parent.Parent != null)
                                                url = "/" + parent.Name + url;
                                        }
                                        return url.ToUrl();
                                    }))
                .Repeat.Any();
            mocks.Replay(parser);

            persister = TestSupport.SetupFakePersister();
        }

 public CreateUrlProvider(IPersister persister, IEditUrlManager editUrlManager, IDefinitionManager definitions, ContentActivator activator, Navigator navigator)
 {
     this.persister = persister;
     this.managementPaths = editUrlManager;
     this.definitions = definitions;
     this.activator = activator;
     this.navigator = navigator;
 }

		public InstallationManager(ConnectionMonitor connectionContext, Importer importer, IWebContext webContext, IPersister persister, ContentActivator activator)
		{
			this.connectionContext = connectionContext;
			this.importer = importer;
			this.webContext = webContext;
			this.persister = persister;
			this.activator = activator;
		}

 public SecurityEnforcer(Persistence.IPersister persister, ISecurityManager security, ContentActivator activator, Web.IUrlParser urlParser, Web.IWebContext webContext)
 {
     this.webContext = webContext;
     this.persister = persister;
     this.security = security;
     this.activator = activator;
     this.urlParser = urlParser;
 }

		public ItemXmlReader(IDefinitionManager definitions, ContentActivator activator)
		{
			if (definitions == null)
				throw new ArgumentNullException("definitions");

			this.definitions = definitions;
			this.activator = activator;
			this.readers = DefaultReaders();
		}

 public SecurityEnforcer(Persistence.IPersister persister, ISecurityManager security, ContentActivator activator, Web.IUrlParser urlParser, Web.IWebContext webContext, Configuration.HostSection config)
 {
     this.webContext = webContext;
     this.persister = persister;
     this.security = security;
     this.activator = activator;
     this.urlParser = urlParser;
     this.permissionDeniedHttpCode = config.Web.PermissionDeniedHttpCode;
 }

 public CreateUrlProvider(IPersister persister, IEditUrlManager editUrlManager, IDefinitionManager definitions, ITemplateProvider[] templates, ContentActivator activator, AjaxRequestDispatcher dispatcher, Navigator navigator)
     : base(dispatcher)
 {
     this.persister = persister;
     this.managementPaths = editUrlManager;
     this.definitions = definitions;
     this.templates = templates;
     this.activator = activator;
     this.navigator = navigator;
 }

        public ViewTemplateProvider(ViewTemplateRegistrator registrator, ViewTemplateAnalyzer analyzer, ContentActivator activator, DefinitionBuilder builder, IProvider<HttpContextBase> httpContextProvider, IProvider<VirtualPathProvider> vppProvider)
        {
            this.registrator = registrator;
            this.analyzer = analyzer;
            this.activator = activator;
            this.builder = builder;
            this.httpContextProvider = httpContextProvider;
            this.vppProvider = vppProvider;

            registrator.RegistrationAdded += (s, a) => rebuild = true;
        }

 public CreateUrlProvider(IPersister persister, IEditUrlManager editUrlManager, IDefinitionManager definitions, ITemplateAggregator templates, ContentActivator activator, Navigator navigator, IVersionManager versions, ContentVersionRepository versionRepository)
 {
     this.persister = persister;
     this.managementPaths = editUrlManager;
     this.definitions = definitions;
     this.templates = templates;
     this.activator = activator;
     this.navigator = navigator;
     this.versions = versions;
     this.versionRepository = versionRepository;
 }

 public InstallationManager(IHost host, IDefinitionManager definitions, ContentActivator activator, Importer importer, IPersister persister, ISessionProvider sessionProvider, IConfigurationBuilder configurationBuilder, IWebContext webContext)
 {
     this.host = host;
     this.definitions = definitions;
     this.activator = activator;
     this.importer = importer;
     this.persister = persister;
     this.sessionProvider = sessionProvider;
     this.configurationBuilder = configurationBuilder;
     this.webContext = webContext;
 }

 public InstallationManager(IHost host, DefinitionMap map, ContentActivator activator, Importer importer, IPersister persister, ISessionProvider sessionProvider, IConfigurationBuilder configurationBuilder, IWebContext webContext, ConnectionMonitor connectionContext)
 {
     this.host = host;
     this.map = map;
     this.activator = activator;
     this.importer = importer;
     this.persister = persister;
     this.sessionProvider = sessionProvider;
     this.configurationBuilder = configurationBuilder;
     this.webContext = webContext;
     this.connectionContext = connectionContext;
 }

		public InstallationManager(IHost host, DefinitionMap map, ContentActivator activator, Importer importer, IPersister persister, ISessionProvider sessionProvider, IConfigurationBuilder configurationBuilder, IWebContext webContext, ConnectionMonitor connectionContext, DatabaseSection config)
		{
			this.host = host;
			this.map = map;
			this.activator = activator;
			this.importer = importer;
			this.persister = persister;
			this.sessionProvider = sessionProvider;
			this.configurationBuilder = configurationBuilder;
			this.webContext = webContext;
			this.connectionContext = connectionContext;
			this.isDatabaseFileSystemEnbled = config.Files.StorageLocation == FileStoreLocation.Database;
		}

        public override void SetUp()
        {
            CreateDatabaseSchema();
            base.SetUp();

            persister = engine.Resolve<IPersister>();
			activator = engine.Resolve<ContentActivator>();
            editManager = engine.Resolve<IEditManager>();
            versionManager = engine.Resolve<IVersionManager>();

            editors = new Dictionary<string, Control>();
            editors["Title"] = new TextBox { Text = "New title" };
        }