コード例 #1
0
        public void TestComponentNameArgQuotes()
        {
            Console.WriteLine("TestComponentNameArgQuotes");

            ConfigFile configFile = new ConfigFile();

            // setup configuration
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ComponentCmd component = new ComponentCmd();

            setupConfiguration.Children.Add(component);
            component.id               = "cmd1";
            component.display_name     = "command 1";
            component.command          = "cmd.exe /C dir";
            component.required_install = true;
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions(configFilename);
            options.args = "/ComponentArgs \"command 1\":\"INSTALLLOCATION=\"\"C:\\Program Files\\FooBar\"\" & exit /b 123\"";
            Assert.AreEqual(123, dotNetInstallerExeUtils.Run(options));
            File.Delete(configFilename);
        }
コード例 #2
0
        public void TestUserControlEditInstalledCheckDisplay()
        {
            Console.WriteLine("TestUserControlEditInstalledCheckDisplay");

            // a configuration with a checkbox control
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ControlEdit edit = new ControlEdit();

            edit.Text  = "4";
            edit.Id    = "edit1";
            edit.Check = ControlCheckType.display;
            setupConfiguration.Children.Add(edit);
            // an installed check that is always false
            InstalledCheckRegistry check = new InstalledCheckRegistry();

            check.path       = @"SOFTWARE\KeyDoesntExist";
            check.comparison = installcheckregistry_comparison.exists;
            edit.Children.Add(check);
            ComponentCmd cmd = new ComponentCmd();

            cmd.command          = "cmd.exe /C exit /b [edit1]5";
            cmd.required_install = true;
            setupConfiguration.Children.Add(cmd);
            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            // execute dotNetInstaller
            Assert.AreEqual(5, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
        }
コード例 #3
0
        public void TestUninstallSwitch()
        {
            Console.WriteLine("TestUninstallSwitch");

            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ComponentCmd cmd = new ComponentCmd();

            setupConfiguration.Children.Add(cmd);
            cmd.command            = "cmd.exe /C exit /b 1"; // would fail if ran
            cmd.required_install   = true;
            cmd.uninstall_command  = "cmd.exe /C exit /b 0";
            cmd.supports_install   = true;
            cmd.supports_uninstall = true;
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            // execute uninstall
            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions(configFilename);
            options.uninstall = false;
            Assert.AreNotEqual(0, dotNetInstallerExeUtils.Run(options));
            options.uninstall = true;
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(options));
            File.Delete(configFilename);
        }
コード例 #4
0
        public void TestNoAutoStart()
        {
            Console.WriteLine("TestNoAutoStart");

            ConfigFile configFile = new ConfigFile();
            // setup configuration
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            setupConfiguration.auto_start             = false;
            setupConfiguration.installation_completed = string.Empty;
            configFile.Children.Add(setupConfiguration);
            // dummy component
            ComponentCmd component = new ComponentCmd();

            setupConfiguration.Children.Add(component);
            component.command = "cmd.exe /C exit /b 0";
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions(configFilename);
            options.quiet = false;
            Process p = dotNetInstallerExeUtils.Detach(options);

            Assert.IsFalse(p.WaitForExit(2 * 1000));
            p.Kill();
            p.WaitForExit();
            Assert.AreEqual(-1, p.ExitCode);
            File.Delete(configFilename);
        }
コード例 #5
0
        public void TestUserControlEdit()
        {
            Console.WriteLine("TestUserControlEdit");

            // a configuration with a checkbox control
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ControlEdit edit = new ControlEdit();

            edit.Text = "4";
            edit.Id   = "edit1";
            setupConfiguration.Children.Add(edit);
            ComponentCmd cmd = new ComponentCmd();

            cmd.command          = "cmd.exe /C exit /b [edit1]";
            cmd.required_install = true;
            setupConfiguration.Children.Add(cmd);

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            Assert.AreEqual(4, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
        }
コード例 #6
0
        public void TestNoUserControl()
        {
            Console.WriteLine("TestNoUserControl");

            // a configuration wthout a user control, value is blank
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ComponentCmd cmd = new ComponentCmd();

            cmd.command          = "cmd.exe /C exit /b [doesntexist]5[doesntexist]";
            cmd.required_install = true;
            setupConfiguration.Children.Add(cmd);

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            Assert.AreEqual(5, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
        }
コード例 #7
0
        public void TestFailingComponent()
        {
            Console.WriteLine("TestFailingComponent");

            // a configuration with a component that fails, complete command is not executed
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            string markerFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".tmp");

            setupConfiguration.complete_command        = string.Format("cmd.exe /C dir > \"{0}\"", markerFilename);
            setupConfiguration.complete_command_basic  = setupConfiguration.complete_command;
            setupConfiguration.complete_command_silent = setupConfiguration.complete_command;
            ComponentCmd component = new ComponentCmd();

            setupConfiguration.Children.Add(component);
            component.command          = "cmd.exe /C exit /b 123";
            component.required_install = true;

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            Assert.AreEqual(123, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
            Assert.IsFalse(File.Exists(markerFilename));
        }
コード例 #8
0
        public void TestOptionalComponentWithoutCheck()
        {
            // a configuration with an optional component, complete command is executed
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();
            string             markerFilename     = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());

            setupConfiguration.supports_uninstall      = false; // otherwise would automatically switch to uninstall
            setupConfiguration.complete_command        = string.Format("cmd.exe /C dir > \"{0}.ui\"", markerFilename);
            setupConfiguration.complete_command_basic  = string.Format("cmd.exe /C dir > \"{0}.basic\"", markerFilename);
            setupConfiguration.complete_command_silent = string.Format("cmd.exe /C dir > \"{0}.silent\"", markerFilename);
            configFile.Children.Add(setupConfiguration);

            // required component that will run, but has no installed check
            ComponentCmd cmd1 = new ComponentCmd();

            setupConfiguration.Children.Add(cmd1);
            cmd1.required_install = false;
            cmd1.command          = "cmd.exe /C exit /b 0";

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
            Assert.IsTrue(File.Exists(markerFilename + ".silent"));
            File.Delete(markerFilename);
        }
コード例 #9
0
        public void TestUserControlBrowseDrive()
        {
            Console.WriteLine("TestUserControlBrowseDrive");

            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ControlBrowse browse = new ControlBrowse();

            browse.Text = @"C:\";
            browse.Id   = "browse1";
            setupConfiguration.Children.Add(browse);
            ComponentCmd cmd = new ComponentCmd();

            cmd.command = "cmd.exe /C if \"[browse1]\"==\"C:\\\" ( exit /b 0 ) else ( exit /b 1 )";
            setupConfiguration.Children.Add(cmd);

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
        }
コード例 #10
0
        public void TestUserControlBrowseControlArgs()
        {
            Console.WriteLine("TestUserControlBrowseControlArgs");

            // a configuration with a checkbox control
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ControlBrowse browse = new ControlBrowse();

            browse.Text = "4";
            browse.Id   = "browse1";
            setupConfiguration.Children.Add(browse);
            ComponentCmd cmd = new ComponentCmd();

            cmd.command          = "cmd.exe /C exit /b [browse1]";
            cmd.required_install = true;
            setupConfiguration.Children.Add(cmd);

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions();
            options.configFile = configFilename;
            options.args       = "/controlArgs browse1:4";
            Assert.AreEqual(4, dotNetInstallerExeUtils.Run(options));
            File.Delete(configFilename);
        }
コード例 #11
0
        public void TestUserControlImage()
        {
            Console.WriteLine("TestUserControlImage");

            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ControlImage image = new ControlImage();

            image.ResourceId = "RES_BANNER_DOESNTEXIST";
            setupConfiguration.Children.Add(image);
            ComponentCmd cmd = new ComponentCmd();

            cmd.command = "cmd.exe /C exit /b 0";
            setupConfiguration.Children.Add(cmd);
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            Assert.AreEqual(-1, dotNetInstallerExeUtils.Run(configFilename));
            image.ResourceId = "RES_BANNER";
            configFile.SaveAs(configFilename);
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
        }
コード例 #12
0
        public void TestRebootExitCode()
        {
            Console.WriteLine("TestRebootExitCode");

            // reboot exit code doesn't override a previous error
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ComponentCmd cmd_error = new ComponentCmd();

            cmd_error.command                   = "cmd.exe /C exit /b 42";
            cmd_error.required_install          = true;
            cmd_error.allow_continue_on_error   = true;
            cmd_error.default_continue_on_error = true;
            setupConfiguration.Children.Add(cmd_error);
            ComponentCmd cmd_reboot = new ComponentCmd();

            cmd_reboot.command            = "cmd.exe /C exit /b 3010";
            cmd_error.required_install    = true;
            cmd_reboot.returncodes_reboot = "3010";
            setupConfiguration.Children.Add(cmd_reboot);
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            Assert.AreEqual(42, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
            dotNetInstallerExeUtils.DisableRunOnReboot();
        }
コード例 #13
0
        public void TestUserControlHyperlink()
        {
            Console.WriteLine("TestUserControlHyperlink");

            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ControlHyperlink hyperlink = new ControlHyperlink();

            hyperlink.Text = "url";
            hyperlink.Uri  = "http://dotnetinstaller.codeplex.com";
            setupConfiguration.Children.Add(hyperlink);
            ComponentCmd cmd = new ComponentCmd();

            cmd.command = "cmd.exe /C exit /b 0";
            setupConfiguration.Children.Add(cmd);

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
        }
コード例 #14
0
        public void TestAllArgCmd()
        {
            Console.WriteLine("TestAllArgCmd");

            ConfigFile configFile = new ConfigFile();

            // setup configuration
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ComponentCmd component1 = new ComponentCmd();

            setupConfiguration.Children.Add(component1);
            component1.id               = "cmd1";
            component1.display_name     = "command 1";
            component1.command          = "cmd.exe /C exit /b ";
            component1.required_install = true;
            ComponentCmd component2 = new ComponentCmd();

            setupConfiguration.Children.Add(component2);
            component2.id               = "cmd2";
            component2.display_name     = "command 2";
            component2.command          = "cmd.exe /C exit /b ";
            component2.required_install = true;
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions(configFilename);
            options.args = "/ComponentArgs *:\"23\"";
            Assert.AreEqual(23, dotNetInstallerExeUtils.Run(options));
            File.Delete(configFilename);
        }
コード例 #15
0
        public void TestComponentArgIgnored()
        {
            Console.WriteLine("TestComponentArgIgnored");

            ConfigFile configFile = new ConfigFile();

            // setup configuration
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ComponentCmd component = new ComponentCmd();

            setupConfiguration.Children.Add(component);
            component.id           = "cmd1";
            component.display_name = "command 1";
            component.command      = "cmd.exe /C exit /b 0";
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions(configFilename);
            options.args = "/ComponentArgs cmddoesntexist:\"& exit /b 123\"";
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(options));
            File.Delete(configFilename);
        }
コード例 #16
0
        public void TestContinueOnErrorNoMessage()
        {
            Console.WriteLine("TestContinueOnErrorNoMessage");

            // test that with all failed_exec_command_continue blanked,
            // user is never asked a question in full UI mode (not blocked)
            ConfigFile         configFile         = new ConfigFile();
            string             markerFilename     = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
            string             markerFilename1    = string.Format("{0}.1", markerFilename);
            string             markerFilename2    = string.Format("{0}.2", markerFilename);
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);

            // running in full UI mode, auto-start
            setupConfiguration.auto_start = true;

            // running in full UI mode, installation is expected to fail, auto-close
            setupConfiguration.auto_close_on_error    = true;
            setupConfiguration.installation_none      = string.Empty;
            setupConfiguration.installation_completed = string.Empty;
            ComponentCmd cmd1 = new ComponentCmd();

            setupConfiguration.Children.Add(cmd1);
            cmd1.command          = string.Format("cmd.exe /C dir > \"{0}\" & exit /b 1", markerFilename1);
            cmd1.required_install = true;
            ComponentCmd cmd2 = new ComponentCmd();

            setupConfiguration.Children.Add(cmd2);
            cmd2.command          = string.Format("cmd.exe /C dir > \"{0}\" & exit /b 2", markerFilename2);
            cmd2.required_install = true;

            // continue on error by default -> continues on the first and the second component, returns the last error code
            cmd1.default_continue_on_error = true;
            cmd2.default_continue_on_error = true;

            // remove all continue or stop error messages
            setupConfiguration.failed_exec_command_continue = string.Empty;
            cmd1.failed_exec_command_continue = string.Empty;
            cmd1.failed_exec_command_continue = string.Empty;
            cmd2.failed_exec_command_continue = string.Empty;

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // the return code of the first failure is saved
            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions(configFilename);

            // all continue error messages are blank, nothing should popup to block the test
            options.quiet = false;
            Assert.AreEqual(1, dotNetInstallerExeUtils.Run(options));
            Assert.IsTrue(File.Exists(markerFilename1));
            Assert.IsTrue(File.Exists(markerFilename2));
            File.Delete(markerFilename1);
            File.Delete(markerFilename2);
            File.Delete(configFilename);
        }
コード例 #17
0
        public void TestEmbedSplashScreen()
        {
            InstallerLinkerArguments args = new InstallerLinkerArguments();

            try
            {
                Uri                uri                = new Uri(Assembly.GetExecutingAssembly().CodeBase);
                string             binPath            = Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath));
                ConfigFile         configFile         = new ConfigFile();
                SetupConfiguration setupConfiguration = new SetupConfiguration();
                configFile.Children.Add(setupConfiguration);
                ComponentCmd cmd = new ComponentCmd();
                cmd.command = "cmd.exe /C exit /b 0";
                setupConfiguration.Children.Add(cmd);
                args.config = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");
                Console.WriteLine("Writing '{0}'", args.config);
                configFile.SaveAs(args.config);
                args.output = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".exe");
                Console.WriteLine("Linking '{0}'", args.output);
                args.template = dotNetInstallerExeUtils.Executable;

                string relativePathName   = "res";
                bool   usingHtmlInstaller = dotNetInstallerExeUtils.Executable.EndsWith("htmlInstaller.exe");
                if (usingHtmlInstaller)
                {
                    relativePathName = "Html";
                }

                args.splash = Path.Combine(dotNetInstallerExeUtils.Location, string.Format(@"..\{0}\banner.bmp", relativePathName));
                InstallerLib.InstallerLinker.CreateInstaller(args);
                // check that the linker generated output
                Assert.IsTrue(File.Exists(args.output));
                Assert.IsTrue(new FileInfo(args.output).Length > 0);
                using (ResourceInfo ri = new ResourceInfo())
                {
                    ri.Load(args.output);
                    Assert.IsTrue(ri.Resources.ContainsKey(new ResourceId("CUSTOM")));
                    List <Resource> custom = ri.Resources[new ResourceId("CUSTOM")];
                    Assert.AreEqual("RES_BANNER", custom[0].Name.Name);
                    Assert.AreEqual("RES_CONFIGURATION", custom[1].Name.ToString());
                    Assert.AreEqual("RES_SPLASH", custom[2].Name.ToString());
                }
                // execute with and without splash
                dotNetInstallerExeUtils.Run(args.output, "/qb");
                dotNetInstallerExeUtils.Run(args.output, "/qb /nosplash");
            }
            finally
            {
                if (File.Exists(args.config))
                {
                    File.Delete(args.config);
                }
                if (File.Exists(args.output))
                {
                    File.Delete(args.output);
                }
            }
        }
コード例 #18
0
        public void TestConfigurationLcid()
        {
            // a configuration with one component
            ConfigFile configFile = new ConfigFile();

            // current lcid setup configuration
            SetupConfiguration currentLcidConfiguration = new SetupConfiguration();

            currentLcidConfiguration.lcid_filter = CultureInfo.CurrentUICulture.LCID.ToString();
            configFile.Children.Add(currentLcidConfiguration);
            string       currentLcidFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
            ComponentCmd cmdCurrentLcid      = new ComponentCmd();

            Console.WriteLine("Current lcid: {0}", currentLcidConfiguration.lcid_filter);
            cmdCurrentLcid.command          = string.Format("cmd.exe /C dir > \"{0}\" & exit /b 0", currentLcidFilename);
            cmdCurrentLcid.required_install = true;
            currentLcidConfiguration.Children.Add(cmdCurrentLcid);

            // empty lcid setup configuration
            SetupConfiguration emptyLcidConfiguration = new SetupConfiguration();

            configFile.Children.Add(emptyLcidConfiguration);
            string       emptyLcidFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
            ComponentCmd cmdEmptyLcid      = new ComponentCmd();

            cmdEmptyLcid.command          = string.Format("cmd.exe /C dir > \"{0}\" & exit /b 0", emptyLcidFilename);
            cmdEmptyLcid.required_install = true;
            emptyLcidConfiguration.Children.Add(cmdEmptyLcid);

            // another lcid setup configuration
            SetupConfiguration anotherLcidConfiguration = new SetupConfiguration();

            anotherLcidConfiguration.lcid_filter = (CultureInfo.CurrentCulture.LCID + 1).ToString();
            configFile.Children.Add(anotherLcidConfiguration);
            string       anotherLcidFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
            ComponentCmd cmdAnotherLcid      = new ComponentCmd();

            Console.WriteLine("Another lcid: {0}", anotherLcidConfiguration.lcid_filter);
            cmdAnotherLcid.command          = string.Format("cmd.exe /C dir > \"{0}\" & exit /b 0", anotherLcidFilename);
            cmdAnotherLcid.required_install = true;
            anotherLcidConfiguration.Children.Add(cmdAnotherLcid);

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(configFilename));
            Assert.IsTrue(File.Exists(currentLcidFilename));
            Assert.IsTrue(File.Exists(emptyLcidFilename));
            Assert.IsFalse(File.Exists(anotherLcidFilename));
            File.Delete(currentLcidFilename);
            File.Delete(emptyLcidFilename);
            File.Delete(configFilename);
        }
コード例 #19
0
        public void TestContinueOnError()
        {
            Console.WriteLine("TestContinueOnError");

            ConfigFile         configFile         = new ConfigFile();
            string             markerFilename     = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
            string             markerFilename1    = string.Format("{0}.1", markerFilename);
            string             markerFilename2    = string.Format("{0}.2", markerFilename);
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ComponentCmd cmd1 = new ComponentCmd();

            setupConfiguration.Children.Add(cmd1);
            cmd1.command          = string.Format("cmd.exe /C dir > \"{0}\" & exit /b 1", markerFilename1);
            cmd1.required_install = true;
            ComponentCmd cmd2 = new ComponentCmd();

            setupConfiguration.Children.Add(cmd2);
            cmd2.command          = string.Format("cmd.exe /C dir > \"{0}\" & exit /b 2", markerFilename2);
            cmd2.required_install = true;

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            Assert.AreEqual(1, dotNetInstallerExeUtils.Run(configFilename));
            Assert.IsTrue(File.Exists(markerFilename1));
            Assert.IsFalse(File.Exists(markerFilename2));
            File.Delete(markerFilename1);

            // allow continue on error (user prompted) -> no effect, this is a prompt that defaults to false in silent mode
            cmd1.allow_continue_on_error = true;
            cmd2.allow_continue_on_error = true;
            configFile.SaveAs(configFilename);
            Assert.AreEqual(1, dotNetInstallerExeUtils.Run(configFilename));
            Assert.IsTrue(File.Exists(markerFilename1));
            Assert.IsFalse(File.Exists(markerFilename2));
            File.Delete(markerFilename1);

            // continue on error by default -> continues on the first and the second component, returns the last error code
            cmd1.default_continue_on_error = true;
            cmd2.default_continue_on_error = true;
            configFile.SaveAs(configFilename);

            // the return code of the first failure is saved
            Assert.AreEqual(1, dotNetInstallerExeUtils.Run(configFilename));
            Assert.IsTrue(File.Exists(markerFilename1));
            Assert.IsTrue(File.Exists(markerFilename2));
            File.Delete(markerFilename1);
            File.Delete(markerFilename2);
            File.Delete(configFilename);
        }
コード例 #20
0
        public void TestExtractAndRunCabPerComponent()
        {
            Console.WriteLine("TestExtractAndRunCabPerComponent");

            InstallerLinkerArguments args = new InstallerLinkerArguments();

            args.config = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");
            Console.WriteLine("Writing '{0}'", args.config);
            args.embed    = true;
            args.apppath  = Path.GetTempPath();
            args.output   = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".exe");
            args.template = dotNetInstallerExeUtils.Executable;

            // create a self-extracting bootstrapper
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            setupConfiguration.cab_path            = Path.Combine(Path.GetTempPath(), "testExtractAndRunCabPerComponent");
            setupConfiguration.cab_path_autodelete = false;
            configFile.Children.Add(setupConfiguration);
            ComponentCmd component = new ComponentCmd();

            component.command          = "cmd.exe /C copy \"#CABPATH\\component\\before.xml\" \"#CABPATH\\component\\after.xml\"";
            component.required_install = true;
            setupConfiguration.Children.Add(component);
            EmbedFile embedfile = new EmbedFile();

            embedfile.sourcefilepath = args.config;
            embedfile.targetfilepath = @"component\before.xml";
            component.Children.Add(embedfile);
            configFile.SaveAs(args.config);
            Console.WriteLine("Linking '{0}'", args.output);
            InstallerLinkerExeUtils.CreateInstaller(args);
            Assert.IsTrue(File.Exists(args.output));

            // execute dotNetInstaller
            string logfile = Path.Combine(Path.GetTempPath(), "testExtractAndRunCabPerComponent.log");

            Console.WriteLine("Log: {0}", logfile);
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(args.output, string.Format("/qb /log /logfile \"{0}\"", logfile)));
            string extractedComponentPath = Path.Combine(setupConfiguration.cab_path, "component");

            Console.WriteLine("Checking {0}", extractedComponentPath);
            Assert.IsTrue(Directory.Exists(extractedComponentPath), string.Format("Missing {0}", extractedComponentPath));
            Assert.IsTrue(File.Exists(Path.Combine(Path.GetTempPath(), @"testExtractAndRunCabPerComponent\component\before.xml")));
            Assert.IsTrue(File.Exists(Path.Combine(Path.GetTempPath(), @"testExtractAndRunCabPerComponent\component\after.xml")));
            File.Delete(args.config);
            File.Delete(args.output);
            Directory.Delete(setupConfiguration.cab_path, true);
            File.Delete(logfile);
        }
コード例 #21
0
        public void TestExtractCabTwoComponentsSameName()
        {
            Console.WriteLine("TestExtractCabTwoComponentsSameName");

            InstallerLinkerArguments args = new InstallerLinkerArguments();

            args.config = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");
            Console.WriteLine("Writing '{0}'", args.config);
            args.embed    = true;
            args.apppath  = Path.GetTempPath();
            args.output   = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".exe");
            args.template = dotNetInstallerExeUtils.Executable;

            // create a self-extracting bootstrapper
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);

            for (int i = 0; i < 2; i++)
            {
                ComponentCmd component = new ComponentCmd();
                component.id = "component";
                setupConfiguration.Children.Add(component);
                EmbedFile embedfile = new EmbedFile();
                embedfile.sourcefilepath = args.config;
                embedfile.targetfilepath = string.Format("component{0}\\file.xml", i);
                component.Children.Add(embedfile);
            }

            configFile.SaveAs(args.config);
            Console.WriteLine("Linking '{0}'", args.output);
            InstallerLinkerExeUtils.CreateInstaller(args);
            Assert.IsTrue(File.Exists(args.output));

            // execute dotNetInstaller
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(args.output, "/ExtractCab"));

            // this should have created a directory called SupportFiles in the current directory
            string supportFilesPath = Path.Combine(Path.GetDirectoryName(args.output), "SupportFiles");

            Console.WriteLine("Checking {0}", supportFilesPath);
            Assert.IsTrue(Directory.Exists(supportFilesPath), string.Format("Missing {0}", supportFilesPath));
            Assert.IsTrue(Directory.Exists(supportFilesPath + @"\component0"));
            Assert.IsTrue(File.Exists(supportFilesPath + @"\component0\file.xml"));
            Assert.IsTrue(Directory.Exists(supportFilesPath + @"\component1"));
            Assert.IsTrue(File.Exists(supportFilesPath + @"\component1\file.xml"));
            File.Delete(args.config);
            File.Delete(args.output);
            Directory.Delete(supportFilesPath, true);
        }
コード例 #22
0
        public void TestUserControlCheckboxInstallCheck()
        {
            Console.WriteLine("TestUserControlCheckboxInstallCheck");

            // a configuration with a checkbox control which has an installed check that disables it
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);

            // a checkbox that changes are return value
            ControlCheckBox checkbox = new ControlCheckBox();

            checkbox.UncheckedValue = "3";
            checkbox.CheckedValue   = "4";
            checkbox.Checked        = true;
            checkbox.Id             = "checkbox1";
            setupConfiguration.Children.Add(checkbox);

            // an installed check that is always false
            InstalledCheckRegistry check = new InstalledCheckRegistry();

            check.path       = @"SOFTWARE\KeyDoesntExist";
            check.comparison = installcheckregistry_comparison.exists;
            checkbox.Children.Add(check);

            // command that depends on the value of checkbox1
            ComponentCmd cmd = new ComponentCmd();

            cmd.command          = "cmd.exe /C exit /b [checkbox1]5";
            cmd.required_install = true;
            setupConfiguration.Children.Add(cmd);

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller, this checkbox is disabled, so all runs ignore checkbox1 value
            Assert.AreEqual(5, dotNetInstallerExeUtils.Run(configFilename));
            checkbox.Checked = false;
            configFile.SaveAs(configFilename);
            Assert.AreEqual(5, dotNetInstallerExeUtils.Run(configFilename));
            checkbox.Checked      = true;
            checkbox.CheckedValue = "0";
            configFile.SaveAs(configFilename);
            Assert.AreEqual(5, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
        }
コード例 #23
0
        public void TestAutoClosesBeforeInstallWhenComponentIsAlreadyInstalled()
        {
            Console.WriteLine("TestAutoClosesBeforeInstallWhenComponentIsAlreadyInstalled");

            // configuration with a component that is already installed and so dni will auto close

            // marker that makes installed check succeed before installation
            string markerFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());

            File.Create(markerFilename).Close();

            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            setupConfiguration.auto_start = true;
            setupConfiguration.auto_close_if_installed = true;
            setupConfiguration.installation_completed  = null;
            setupConfiguration.installation_none       = null;
            setupConfiguration.supports_uninstall      = false; // prevent switching to uninstall
            configFile.Children.Add(setupConfiguration);

            // dummy component
            ComponentCmd component = new ComponentCmd();

            setupConfiguration.Children.Add(component);
            component.required_install = true;
            component.supports_install = true;
            component.command          = string.Format("cmd.exe /C dir > \"{0}\"", markerFilename);

            InstalledCheckFile check = new InstalledCheckFile();

            check.filename   = markerFilename;
            check.comparison = installcheckfile_comparison.exists;
            component.Children.Add(check);

            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions(configFilename);
            options.quiet = false;

            // will auto close since all components are already installed
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(options, TimeSpan.FromSeconds(3)));

            File.Delete(configFilename);
            File.Delete(markerFilename);
        }
コード例 #24
0
        public void TestDefaultSelectionUninstall()
        {
            Console.WriteLine("TestDefaultSelectionUninstall");

            InstalledCheckFile existsCheck = new InstalledCheckFile();

            existsCheck.filename   = dotNetInstallerExeUtils.Executable;
            existsCheck.comparison = installcheckfile_comparison.exists;
            ConfigFile configFile = new ConfigFile();

            // setup configuration
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);

            // dummy component 1
            ComponentCmd component1 = new ComponentCmd();

            setupConfiguration.Children.Add(component1);
            component1.uninstall_command  = "cmd.exe /C exit /b 57";
            component1.selected_uninstall = true;
            component1.supports_uninstall = true;
            component1.Children.Add(existsCheck);

            // dummy component 2
            ComponentCmd component2 = new ComponentCmd();

            setupConfiguration.Children.Add(component2);
            component2.uninstall_command  = "cmd.exe /C exit /b 42";
            component2.selected_uninstall = false;
            component2.supports_uninstall = true;
            component2.Children.Add(existsCheck);

            // second component is selected and runs, not the first one
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions(configFilename);
            options.uninstall = true;
            Assert.AreEqual(57, dotNetInstallerExeUtils.Run(options));

            // first component is selected and runs
            component2.selected_uninstall = true;
            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            Assert.AreEqual(42, dotNetInstallerExeUtils.Run(options));
            File.Delete(configFilename);
        }
コード例 #25
0
        public void TestNotAutoClosesAfterInstallWhenComponentInstallFails()
        {
            Console.WriteLine("TestNotAutoClosesAfterInstallWhenComponentInstallFails");

            // configuration with a component that will run and fail and so dni will not auto close

            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            setupConfiguration.auto_start = true;
            setupConfiguration.auto_close_if_installed      = true;
            setupConfiguration.installation_completed       = null;
            setupConfiguration.failed_exec_command_continue = string.Empty;
            configFile.Children.Add(setupConfiguration);

            ComponentCmd cmd = new ComponentCmd();

            cmd.command          = "cmd.exe /C exit /b 1";
            cmd.required_install = true;
            cmd.supports_install = true;
            setupConfiguration.Children.Add(cmd);

            InstalledCheckRegistry check = new InstalledCheckRegistry();

            check.path       = @"SOFTWARE\KeyDoesntExists";
            check.comparison = installcheckregistry_comparison.exists;
            cmd.Children.Add(check);

            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // will not auto close since all required components failed to install
            Assert.AreNotEqual(0, dotNetInstallerExeUtils.Run(configFilename));

            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions(configFilename);
            options.quiet = false;

            Process p = dotNetInstallerExeUtils.Detach(options);

            Assert.IsFalse(p.WaitForExit(3 * 1000));
            p.Kill();
            p.WaitForExit();
            Assert.AreEqual(-1, p.ExitCode);

            File.Delete(configFilename);
        }
コード例 #26
0
        public void TestDownloadConfiguration()
        {
            Console.WriteLine("TestDownloadConfiguration");

            // a configuration with a single component that contains two download components
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ComponentCmd component1 = new ComponentCmd();

            setupConfiguration.Children.Add(component1);
            component1.command          = "cmd.exe /C exit /b 0";
            component1.required_install = true;
            DownloadDialog component1downloaddialog = new DownloadDialog(
                string.Format("{0} Download Dialog", component1.id));

            component1.Children.Add(component1downloaddialog);
            Download component1download1 = new Download();

            component1download1.componentname       = "download 1";
            component1download1.sourceurl           = Assembly.GetExecutingAssembly().Location;
            component1download1.destinationpath     = Path.GetTempPath();
            component1download1.destinationfilename = Guid.NewGuid().ToString();
            component1downloaddialog.Children.Add(component1download1);
            Download component1download2 = new Download();

            component1download2.componentname       = "download 2";
            component1download2.sourceurl           = Assembly.GetExecutingAssembly().Location;
            component1download2.destinationpath     = Path.GetTempPath();
            component1download2.destinationfilename = Guid.NewGuid().ToString();
            component1downloaddialog.Children.Add(component1download2);

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
            Assert.IsTrue(File.Exists(Path.Combine(component1download1.destinationpath, component1download1.destinationfilename)));
            File.Delete(Path.Combine(component1download1.destinationpath, component1download1.destinationfilename));
            Assert.IsTrue(File.Exists(Path.Combine(component1download2.destinationpath, component1download2.destinationfilename)));
            File.Delete(Path.Combine(component1download2.destinationpath, component1download2.destinationfilename));
        }
コード例 #27
0
        public void TestUserControlCheckboxControlArgs()
        {
            Console.WriteLine("TestUserControlCheckboxControlArgs");

            // a configuration with a checkbox control
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);

            // a checkbox that changes are return value
            ControlCheckBox checkbox = new ControlCheckBox();

            checkbox.UncheckedValue = "3";
            checkbox.CheckedValue   = "4";
            checkbox.Checked        = true;
            checkbox.Id             = "checkbox1";
            setupConfiguration.Children.Add(checkbox);
            ComponentCmd cmd = new ComponentCmd();

            cmd.command          = "cmd.exe /C exit /b [checkbox1]";
            cmd.required_install = true;
            setupConfiguration.Children.Add(cmd);

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions();
            options.configFile = configFilename;

            // unchecked value
            options.args = "/controlArgs checkbox1:3";
            Assert.AreEqual(3, dotNetInstallerExeUtils.Run(options));

            // checked value
            options.args = "/controlArgs checkbox1:4";
            Assert.AreEqual(4, dotNetInstallerExeUtils.Run(options));

            // invalid value
            options.args = "/controlArgs checkbox1:5";
            Assert.AreEqual(-1, dotNetInstallerExeUtils.Run(options));
            File.Delete(configFilename);
        }
コード例 #28
0
        public void TestNoDownloadWhenSourceFileExsts()
        {
            Console.WriteLine("TestNoDownloadWhenSourceFileExsts");

            // a configuration where the source file exists, no download dialog should show
            ConfigFile         configFile         = new ConfigFile();
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            configFile.Children.Add(setupConfiguration);
            ComponentCmd cmd = new ComponentCmd();

            setupConfiguration.Children.Add(cmd);
            cmd.command          = "cmd.exe /C exit /b 0";
            cmd.required_install = true;
            DownloadDialog cmddownloaddialog = new DownloadDialog(
                string.Format("{0} Download Dialog", cmd.id));

            cmd.Children.Add(cmddownloaddialog);
            cmddownloaddialog.autostartdownload = false;
            Download download = new Download();

            download.componentname       = "download 1";
            download.sourceurl           = string.Format("http://{0}/dummy.exe", Guid.NewGuid());
            download.sourcepath          = Assembly.GetExecutingAssembly().Location;
            download.destinationpath     = Path.GetTempPath();
            download.destinationfilename = Guid.NewGuid().ToString();
            download.alwaysdownload      = false;
            cmddownloaddialog.Children.Add(download);

            // save config file
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);

            // execute dotNetInstaller
            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions();
            options.configFile = configFilename;
            options.args       = "/qb";
            options.quiet      = false;
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(options));
            File.Delete(configFilename);
            Assert.IsTrue(File.Exists(Path.Combine(download.destinationpath, download.destinationfilename)));
            File.Delete(Path.Combine(download.destinationpath, download.destinationfilename));
        }
コード例 #29
0
        public void TestConfigNoLangID()
        {
            ConfigFile         configFile    = new ConfigFile();
            SetupConfiguration configuration = new SetupConfiguration();

            configFile.Children.Add(configuration);
            ComponentCmd cmd = new ComponentCmd();

            cmd.command          = "cmd.exe /C exit /b #LANGID";
            cmd.required_install = true;
            configuration.Children.Add(cmd);
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            Assert.AreEqual(CultureInfo.CurrentUICulture.LCID, dotNetInstallerExeUtils.Run(configFilename));
            File.Delete(configFilename);
        }
コード例 #30
0
        public void TestAutoStartCmdLine()
        {
            Console.WriteLine("TestAutoStartCmdLine");

            ConfigFile configFile = new ConfigFile();

            // setup configuration
            SetupConfiguration setupConfiguration = new SetupConfiguration();

            setupConfiguration.auto_start = false;
            setupConfiguration.auto_close_if_installed = true;
            setupConfiguration.installation_completed  = string.Empty;
            setupConfiguration.installation_none       = string.Empty;
            configFile.Children.Add(setupConfiguration);

            // marker that makes installed check succeeed after installation
            string markerFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());

            // dummy component
            ComponentCmd component = new ComponentCmd();

            setupConfiguration.Children.Add(component);
            component.command = string.Format("cmd.exe /C dir > \"{0}\"", markerFilename);
            InstalledCheckFile check = new InstalledCheckFile();

            check.filename   = markerFilename;
            check.comparison = installcheckfile_comparison.exists;
            component.Children.Add(check);

            // configuration
            component.installcompletemessage = string.Empty;
            string configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xml");

            Console.WriteLine("Writing '{0}'", configFilename);
            configFile.SaveAs(configFilename);
            dotNetInstallerExeUtils.RunOptions options = new dotNetInstallerExeUtils.RunOptions(configFilename);
            options.quiet     = false;
            options.reboot    = false;
            options.autostart = true;
            Assert.AreEqual(0, dotNetInstallerExeUtils.Run(options));
            Assert.IsTrue(File.Exists(markerFilename));
            File.Delete(configFilename);
            File.Delete(markerFilename);
        }