public void Fill(Installer installer)
 {
     foreach (Installer installer2 in this.CreateInstallers(this.InstrumentedTypes))
     {
         installer.Installers.Add(installer2);
     }
 }

	public void SetUp ()
	{
		ins = new Installer ();
		state = new Hashtable ();
		sub1 = new MyInstaller ();
		sub2 = new MyInstaller ();

		BfInstEvt = new CallInfo ();
		AfInstEvt = new CallInfo ();
		CommittingEvt = new CallInfo ();
		CommittedEvt = new CallInfo ();
		BfRbackEvt = new CallInfo ();
		AfRbackEvt = new CallInfo ();
		BfUninsEvt = new CallInfo ();
		AfUninsEvt = new CallInfo ();;

		ins.Installers.Add (sub1);
		ins.Installers.Add (sub2);

		ins.BeforeInstall += new InstallEventHandler (onBeforeInstall);
		ins.AfterInstall += new InstallEventHandler (onAfterInstall);
		ins.Committing += new InstallEventHandler (onCommitting);
		ins.Committed += new InstallEventHandler (onCommitted);
		ins.BeforeRollback += new InstallEventHandler (onBeforeRollback);
		ins.AfterRollback += new InstallEventHandler (onAfterRollback);
		ins.BeforeUninstall += new InstallEventHandler (onBeforeUninstall);
		ins.AfterUninstall += new InstallEventHandler (onAfterUninstall);
	}

	public void SetUp ()
	{
		ins = new TransactedInstaller ();
		state = new Hashtable ();
		sub1 = new SucceedInstaller ();
		sub2 = new FailureInstaller ();
		sub3 = new SucceedInstaller ();

		BfInstEvt = new CallInfo ();
		AfInstEvt = new CallInfo ();
		CommittingEvt = new CallInfo ();
		CommittedEvt = new CallInfo ();
		BfRbackEvt = new CallInfo ();
		AfRbackEvt = new CallInfo ();
		BfUninsEvt = new CallInfo ();
		AfUninsEvt = new CallInfo ();

		ins.Installers.Add (sub1);
		string [] cmdLine = new string [] { "/logToConsole=false" };
		ins.Context = new InstallContext ("", cmdLine);	// no log file

		ins.BeforeInstall += new InstallEventHandler (onBeforeInstall);
		ins.AfterInstall += new InstallEventHandler (onAfterInstall);
		ins.Committing += new InstallEventHandler (onCommitting);
		ins.Committed += new InstallEventHandler (onCommitted);
		ins.BeforeRollback += new InstallEventHandler (onBeforeRollback);
		ins.AfterRollback += new InstallEventHandler (onAfterRollback);
		ins.BeforeUninstall += new InstallEventHandler (onBeforeUninstall);
		ins.AfterUninstall += new InstallEventHandler (onAfterUninstall);
	}

        public SpHostServiceInstaller(HostSettings settings, HostConfigurator configurator)
        {
            _hostConfigurator = configurator;

            _installer = CreateInstaller(settings);

            _transactedInstaller = CreateTransactedInstaller(_installer);
        }

        public void TypeWithNoEventLogsReturnsUnchangedInstaller()
        {
            Installer parentInstaller = new Installer();
            EventLogInstallerBuilder builder = new EventLogInstallerBuilder(new Type[] { typeof(NoLogsType) });
            builder.Fill(parentInstaller);

            Assert.AreEqual(0, parentInstaller.Installers.Count);
        }

 public DBForm(Installer pInstallerP)
 {
     InitializeComponent();
     LoadProvider();
     normalClose = false;
     pInstaller = pInstallerP;
     dbName = "";
 }

        public ProjectInstaller(Assembly appAssembly)
        {
            _installer = new Installer();
            _appAssembly = appAssembly;

            CreateSubInstallers();
            SetInstallerContext();
        }

        public void TypeWithNoCountersReturnsEmptyInstallers()
        {
            Installer parentInstaller = new Installer();
            PerformanceCounterInstallerBuilder builder
                = new PerformanceCounterInstallerBuilder(new Type[] { typeof(NoCountersType) });
            builder.Fill(parentInstaller);

            Assert.AreEqual(0, parentInstaller.Installers.Count);
        }

 /// <summary>
 /// UnInstalls the Windows service with the given "installer" object.
 /// </summary>
 /// <param name="pi"></param>
 /// <param name="pathToService"></param>
 public static void uninstallService(Installer pi, string pathToService)
 {
     TransactedInstaller ti = new TransactedInstaller ();
     ti.Installers.Add (pi);
     string[] cmdline = {pathToService};
     InstallContext ctx = new InstallContext ("Uninstall.log", cmdline );
     ti.Context = ctx;
     ti.Uninstall ( null );
 }

        /// <summary>
        /// Fills the given installer with other, more specific kinds of installers that have been
        /// filled with the appropriate kinds of installable resources
        /// </summary>
        /// <param name="installer">Outer installer to be filled with nested installers for specific resources</param>
        public void Fill(Installer installer)
        {
            ICollection<Installer> installers = CreateInstallers(InstrumentedTypes);

            foreach (Installer childInstaller in installers)
            {
                installer.Installers.Add(childInstaller);
            }
        }

 /// <summary>
 /// Installs the Windows service with the given "installer" object.
 /// </summary>
 /// <param name="installer">The installer.</param>
 /// <param name="pathToService">The path to service.</param>
 public static void InstallService(Installer installer, string pathToService)
 {
     TransactedInstaller ti = new TransactedInstaller();
     ti.Installers.Add(installer);
     string[] cmdline = { pathToService };
     InstallContext ctx = new InstallContext("Install.log", cmdline);
     ti.Context = ctx;
     ti.Install(new Hashtable());
 }

 public static Installer[] BuildInstallers(WinServiceSettings settings)
 {
     var result = new Installer[]
                  {
                      ConfigureServiceInstaller(settings),
                      ConfigureServiceProcessInstaller(settings)
                  };
     return result;
 }

 public void AddRange(Installer[] value)
 {
     if (value == null)
     {
         throw new ArgumentNullException("value");
     }
     for (int i = 0; i < value.Length; i++)
     {
         this.Add(value[i]);
     }
 }

    // Add a range of installers to this collection.
    public void AddRange(Installer[] value)
			{
				if(value == null)
				{
					throw new ArgumentNullException("value");
				}
				foreach(Installer inst in value)
				{
					Add(inst);
				}
			}

		public void AddRange (Installer[] value) {
			if (value == null) 
			{
				throw new ArgumentNullException ("value");
			}

			for (int counter = 0; counter < value.Length; counter++)
			{
				Add (value[counter]);
			}
		}

		private void InitializeComponent()
		{
			this.serviceProcessInstaller1 = new ServiceProcessInstaller();
			this.serviceInstaller1 = new ServiceInstaller();
			this.serviceProcessInstaller1.Password = null;
			this.serviceProcessInstaller1.Username = null;
			this.serviceInstaller1.ServiceName = "Service1";
			InstallerCollection installers = base.Installers;
			Installer[] installerArray = new Installer[] { this.serviceProcessInstaller1, this.serviceInstaller1 };
			installers.AddRange(installerArray);
		}

        public void BuilderWillFillInstallerWithCreatedChildInstallers()
        {
            Type[] candidateTypes = new Type[] {
                    typeof(InstrumentedTypeWithAAttribute),
                    typeof(InstrumentedTypeWithAAndBAttributes)
                };

            MockInstallerBuilder builder = new MockInstallerBuilder(candidateTypes, typeof(InstrumentationAAttribute));

            Installer parentInstaller = new Installer();
        }

		protected override Installer CreateUninstaller(HostSettings settings, string commandLine)
		{
			var baseInstallers = new Installer[]
			{
				CreateServiceInstaller(settings, new string[] {}, HostStartMode.Automatic),
				CreateServiceProcessInstaller(ServiceAccount.LocalService, "", "")
			};

			var mainInstaller = new HostInstaller(settings, commandLine, baseInstallers);

			return CreateTransactedInstaller(mainInstaller);
		}

        public void WillFindSingleEventLogTypeInListOfTypes()
        {
            Installer parentInstaller = new Installer();
            EventLogInstallerBuilder builder = new EventLogInstallerBuilder(new Type[] { typeof(NoLogsType), typeof(SimpleLogType) });
            builder.Fill(parentInstaller);

            Assert.AreEqual(1, parentInstaller.Installers.Count);
            Assert.AreSame(typeof(EventLogInstaller), parentInstaller.Installers[0].GetType());

            EventLogInstaller installer = (EventLogInstaller)parentInstaller.Installers[0];

            Assert.AreEqual("FooLog", installer.Log);
        }

        internal static void installService()
        {
            ServiceInstaller serviceInstaller = null;
            ServiceProcessInstaller serviceProcessInstaller = null;
            Installer projectInstaller = null;
            TransactedInstaller transactedInstaller = null;
            try
            {
                serviceInstaller = new ServiceInstaller();
                serviceInstaller.ServiceName = "OpenVPNManager";
                serviceInstaller.StartType = ServiceStartMode.Automatic;

                serviceProcessInstaller = new ServiceProcessInstaller();
                serviceProcessInstaller.Account = System.ServiceProcess.ServiceAccount.LocalSystem;
                serviceProcessInstaller.Password = null;
                serviceProcessInstaller.Username = null;

                projectInstaller = new Installer();
                projectInstaller.Installers.Add(serviceInstaller);
                projectInstaller.Installers.Add(serviceProcessInstaller);

                transactedInstaller = new TransactedInstaller();
                transactedInstaller.Installers.Add(projectInstaller);
                transactedInstaller.Context = new InstallContext();
                transactedInstaller.Context.Parameters["assemblypath"] = Assembly.GetExecutingAssembly().Location + "\" \"/EXECUTESERVICE";
                transactedInstaller.Install(new Hashtable());
            }
            catch (InvalidOperationException e)
            {
                if (e.InnerException != null && e.InnerException is Win32Exception)// Probably: "Service already exists."
                    MessageBox.Show("Error: " + e.InnerException.Message);
                else if (e.InnerException != null && e.InnerException is InvalidOperationException && e.InnerException.InnerException != null && e.InnerException.InnerException is Win32Exception)// Probably: "Permission denied"
                {
                    String MSG_ServiceInstallPermissionErrorAdvice = Program.res.GetString("MSG_ServiceInstallPermissionErrorAdvice");
                    MessageBox.Show("Error: " + e.InnerException.InnerException.Message + "\r\n\r\n" + MSG_ServiceInstallPermissionErrorAdvice);
                }
                else
                    throw;
            }
            finally
            {
                if (serviceInstaller != null)
                    serviceInstaller.Dispose();
                if (serviceProcessInstaller != null)
                    serviceProcessInstaller.Dispose();
                if (projectInstaller != null)
                    projectInstaller.Dispose();
                if (transactedInstaller != null)
                    transactedInstaller.Dispose();
            }
        }