private AppDomainSetup BuildSetupInfo()
        {
            AppDomainSetup result = new AppDomainSetup();
            result.ApplicationBase = GetInstallPath();
            return result;

        }

        public void ConvertsAfterAppDomainRecycles()
        {
            // arrange
            Factory.TearDownAppDomain(null, null);

            var pathName = Path.GetDirectoryName(typeof(Factory).Assembly.Location);
            var appDomainSetup = new AppDomainSetup { ApplicationBase = pathName };
            var domain1 = AppDomain.CreateDomain("testing_unload_1", null, appDomainSetup);
            byte[] result1 = null;
            var domain2 = AppDomain.CreateDomain("testing_unload_2", null, appDomainSetup);
            byte[] result2 = null;

            // act
            domain1.DoCallBack(() =>
            {
                byte[] convert = Factory.Create().Convert("<p>some html</p>");
                AppDomain.CurrentDomain.SetData("result1", convert);
            });
            result1 = domain1.GetData("result1") as byte[];
            AppDomain.Unload(domain1);

            domain2.DoCallBack(() =>
            {
                byte[] convert = Factory.Create().Convert("<p>some html</p>");
                AppDomain.CurrentDomain.SetData("result2", convert);
            });
            result2 = domain2.GetData("result2") as byte[];
            AppDomain.Unload(domain2);

            // assert
            Assert.NotNull(result1);
            Assert.NotNull(result2);
        }

        /// <summary>
        /// Creates an AppDomain.
        /// </summary>
        /// <param name="applicationName">The application name for the new AppDomain, or null if none.</param>
        /// <param name="applicationBaseDirectory">The application base directory for the new AppDomain, or null to use the current one.</param>
        /// <param name="configurationFile">The configuration file for the new AppDomain, or null to use the current one.</param>
        /// <param name="enableShadowCopy">If true, enables shadow copying within the AppDomain.</param>
        /// <returns>The new AppDomain.</returns>
        public static AppDomain CreateAppDomain(string applicationName, string applicationBaseDirectory, string configurationFile, bool enableShadowCopy)
        {
            AppDomainSetup appDomainSetup = new AppDomainSetup();

            appDomainSetup.ApplicationName = applicationName ?? string.Empty;
            appDomainSetup.ApplicationBase = applicationBaseDirectory ?? AppDomain.CurrentDomain.BaseDirectory;

            if (configurationFile != null)
            {
                // NOTE: We can also use AppDomainSetup.SetConfigurationBytes but it only applies to
                //       CLR-internal configuration settings such as the assembly binding policy.
                //       In order for other configuration mechanisms to operate correctly, we must
                //       use a real configuration file on disk instead.
                appDomainSetup.ConfigurationFile = configurationFile;
            }

            if (enableShadowCopy)
            {
                appDomainSetup.ShadowCopyFiles = @"true";
                appDomainSetup.ShadowCopyDirectories = null;
            }

            // TODO: Might need to be more careful about how the Evidence is derived.
            Evidence evidence = AppDomain.CurrentDomain.Evidence;
            if (DotNetRuntimeSupport.IsUsingMono)
            {
                return AppDomain.CreateDomain(appDomainSetup.ApplicationName, evidence, appDomainSetup);
            }
            else
            {
                PermissionSet defaultPermissionSet = new PermissionSet(PermissionState.Unrestricted);
                StrongName[] fullTrustAssemblies = new StrongName[0];
                return AppDomain.CreateDomain(appDomainSetup.ApplicationName, evidence, appDomainSetup, defaultPermissionSet, fullTrustAssemblies);
            }
        }

        public void DefaultAppDomainManager_setup_for_web_domains_follows_same_approximate_pattern_as_web_applications()
        {
            var module = new FakeCrosswalkModule
            {
                AppPoolInfo =
                    {
                        AppPoolName = "Testing",
                        ClrConfigFile = @"x:\no-such-folder\testing.config"
                    }
            };
            using (CrosswalkModule.ReplaceCalls(module))
            {
                var manager = new DefaultAppDomainManager();
                var setup = new AppDomainSetup();
                manager.InitializeNewDomain(setup);

                var domainId = module.AppPoolInfo.CreateAppDomain(@"x:\no-such-website\", "ID0", "CFG0");

                // the fake set of calls don't really create another domain
                Assert.That(domainId, Is.EqualTo(AppDomain.CurrentDomain.Id));

                // same default assumptions as a web app
                Assert.That(module.AppDomainSetup.ApplicationBase, Is.EqualTo(@"x:\no-such-website\"));
                Assert.That(module.AppDomainSetup.ConfigurationFile, Is.EqualTo(@"x:\no-such-website\Web.config"));
                Assert.That(module.AppDomainSetup.PrivateBinPath, Is.EqualTo(@"bin"));

                // specified a different class to finish initialization in the new domain
                Assert.That(module.AppDomainSetup.AppDomainManagerType, Is.StringEnding("WebAppDomainManager"));
            }
        }

 public static void WithinAppDomain(string expectedFile, string createdFile, IEnumerable<string> args)
 {
     var bd = AppDomain.CurrentDomain.BaseDirectory;
     var info = new AppDomainSetup()
     {
         ApplicationBase     = bd,
         ApplicationName     = Program + ".exe",
         ConfigurationFile   = Program + ".exe.config",
     };
     AppDomain ad = AppDomain.CreateDomain("DbMetal Sqlite Test", null, info);
     var t = typeof(DbMetalAppDomainSetup);
     var s = (DbMetalAppDomainSetup)ad.CreateInstanceAndUnwrap(t.Assembly.GetName().Name, t.FullName);
     var stderr = new StringWriter();
     s.SetStandardError(stderr);
     var testdir = Path.Combine(bd, Path.Combine("..", "tests"));
     var expectedDir = Path.Combine(testdir, "expected");
     s.Run(new []{
         "/provider:Sqlite",
         "/conn:Data Source=" + Path.Combine(testdir, "Northwind.db3"),
     }.Concat(args).ToArray());
     AppDomain.Unload(ad);
     if (stderr.GetStringBuilder().Length != 0)
         Console.Error.Write(stderr.GetStringBuilder().ToString());
     Assert.AreEqual(0, stderr.GetStringBuilder().Length);
     FileAssert.AreEqual(Path.Combine(expectedDir, string.Format (expectedFile, Program)), createdFile);
     File.Delete(createdFile);
 }

        static void Main(string[] args)
        {
            object[] hostEvidence = { new Zone(SecurityZone.MyComputer) };
            Evidence internetEvidence = new Evidence(hostEvidence, null);
            AppDomain myDomain = AppDomain.CreateDomain("MyDomain");
            myDomain.ExecuteAssembly("SecondAssembly.exe", internetEvidence);

            AppDomainSetup setup = new AppDomainSetup();
            Console.WriteLine(setup.ToString());
            Console.WriteLine(typeof(object));

            objectArrayTest(new object[] { "Hello", "World"});

            AppDomainSetup ads = new AppDomainSetup();
            ads.ApplicationBase = "file://" + Environment.CurrentDirectory;
            ads.DisallowBindingRedirects = false;
            ads.DisallowCodeDownload = true;
            ads.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;

            AppDomain b = AppDomain.CreateDomain("New Domain", null, ads);

            ads = AppDomain.CurrentDomain.SetupInformation;
            Console.WriteLine("ApplicationBase: " + ads.ApplicationBase);
            Console.WriteLine("ApplicationName: " + ads.ApplicationName);
            Console.WriteLine("DisallowCodeDownload: " + ads.DisallowCodeDownload);
            Console.WriteLine("DisallowBindingRedirects: " + ads.DisallowBindingRedirects);
        }

        /// <summary>
        /// Starts this instance.
        /// </summary>
        /// <exception cref="System.InvalidOperationException">Job already started.</exception>
        public static void Start()
        {
            if (_job != null)
                throw new InvalidOperationException("Job already started.");

            var evidence = new Evidence(AppDomain.CurrentDomain.Evidence);
            var setup = new AppDomainSetup
            {
                ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
                ShadowCopyFiles = "false"
            };

            _appDomain = AppDomain.CreateDomain("eSync-" + Guid.NewGuid(), evidence, setup);
            try
            {
                var assembly = _appDomain.Load(typeof(SyncServiceJob).Assembly.GetName());
                var jobTypeName = typeof(SyncServiceJob).FullName;

                _job = (IJob)_appDomain.CreateInstanceAndUnwrap(assembly.FullName, jobTypeName);
                _job.Start();
            }
            catch
            {
                _job = null;
                AppDomain.Unload(_appDomain);
                _appDomain = null;

                throw;
            }
        }

        /// <summary>
        /// Generates one GrainReference class for each Grain Type in the inputLib file 
        /// and output one GrainClient.dll under outputLib directory
        /// </summary>
        private static bool CreateGrainClientAssembly(CodeGenOptions options)
        {
            AppDomain appDomain = null;
            try
            {
                var assembly = typeof (GrainClientGenerator).GetTypeInfo().Assembly;
                // Create AppDomain.
                var appDomainSetup = new AppDomainSetup
                {
                    ApplicationBase = Path.GetDirectoryName(assembly.Location),
                    DisallowBindingRedirects = false,
                    ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile
                };
                appDomain = AppDomain.CreateDomain("Orleans-CodeGen Domain", null, appDomainSetup);

                // Set up assembly resolver
                var refResolver = new ReferenceResolver(options.ReferencedAssemblies);
                appDomain.AssemblyResolve += refResolver.ResolveAssembly;

                // Create an instance 
                var generator =
                    (GrainClientGenerator)
                    appDomain.CreateInstanceAndUnwrap(
                        assembly.FullName,
                        typeof(GrainClientGenerator).FullName);

                // Call a method 
                return generator.CreateGrainClient(options);
            }
            finally
            {
                if (appDomain != null) AppDomain.Unload(appDomain); // Unload the AppDomain
            }
        }

        public IsolatedApplicationRunner()
        {
            var setup = new AppDomainSetup
            {
                ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
                ApplicationName = "Net IDE"
            };

            var appDomain = AppDomain.CreateDomain(
                setup.ApplicationName,
                AppDomain.CurrentDomain.Evidence,
                setup
            );

            try
            {
                _application = (ApplicationRunner)appDomain.CreateInstanceAndUnwrap(
                    typeof(ApplicationRunner).Assembly.FullName,
                    typeof(ApplicationRunner).FullName
                );

                _appDomain = appDomain;
            }
            catch
            {
                AppDomain.Unload(appDomain);

                throw;
            }
        }

        /// <summary>
        /// Created a new <see cref="AppDomain"/> and runs the given PowerShell script.
        /// </summary>
        /// <param name="fileName">The name of the PowerShell script to run.</param>
        /// <param name="configFileName">The name of the configuration file. If you set it to null it will default to <code><paramref name="fileName"/>.config</code>.</param>
        /// <param name="appDomainName">The name of the AppDomain.</param>
        /// <returns>The output of the script as an array of strings.</returns>
        public static string[] RunScriptInNewAppDomain(ADPRConfig configuration)
        {
            var assembly = Assembly.GetExecutingAssembly();

            var setupInfo = new AppDomainSetup
                                {
                                    ApplicationName = configuration.AppDomainName,
                                    ConfigurationFile = configuration.ConfigFile,
                                    // TODO: Perhaps we should setup an even handler to reload the AppDomain similar to ASP.NET in IIS.
                                    ShadowCopyFiles = configuration.ShadowCopyFiles.ToString()
                                };
            var appDomain = AppDomain.CreateDomain(string.Format("AppDomainPoshRunner-{0}", configuration.AppDomainName), null, setupInfo);
            try
            {
            #if NET_35
                var runner = appDomain.CreateInstanceFromAndUnwrap(assembly.Location, typeof(AppDomainPoshRunner).FullName, false, 0, null, new object[] {configuration}, null, null, null);
            #else
                var runner = appDomain.CreateInstanceFromAndUnwrap(assembly.Location, typeof(AppDomainPoshRunner).FullName, false, 0, null, new object[] {configuration}, null, null);
            #endif
                return ((AppDomainPoshRunner)runner).RunScript(new Uri(Path.GetFullPath(configuration.Script)));
            }
            finally
            {
                AppDomain.Unload(appDomain);
            }
        }

        private void OutputHubs(string path, string url, string outputPath)
        {
            path = path ?? Directory.GetCurrentDirectory();
            url = url ?? "/signalr";

            var assemblies = Directory.GetFiles(path, "*.dll", SearchOption.AllDirectories);
            var tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());

            Info(String.Format(CultureInfo.CurrentCulture, Resources.Notify_CreatingTempDirectory, tempPath));

            Directory.CreateDirectory(tempPath);

            // Copy all assemblies to temp
            foreach (var assemblyPath in assemblies)
            {
                Copy(assemblyPath, tempPath);
            }

            Copy(typeof(Program).Assembly.Location, tempPath);

            var setup = new AppDomainSetup
            {
                ApplicationBase = tempPath
            };

            var domain = AppDomain.CreateDomain("hubs", AppDomain.CurrentDomain.Evidence, setup);

            var generator = (JavaScriptGenerator)domain.CreateInstanceAndUnwrap(typeof(Program).Assembly.FullName,
                                                                                typeof(JavaScriptGenerator).FullName);
            var js = generator.GenerateProxy(path, url, Warning);

            Generate(outputPath, js);
        }

        public static string GetVersion(string fileName)
        {
            var setup = new AppDomainSetup
            {
                ApplicationBase = Path.GetDirectoryName(typeof(VersionRetriever).Assembly.Location),
                ApplicationName = "Version Retriever"
            };

            var appDomain = AppDomain.CreateDomain(
                setup.ApplicationName,
                AppDomain.CurrentDomain.Evidence,
                setup
            );

            try
            {
                var retriever = (VersionRetriever)appDomain.CreateInstanceAndUnwrap(
                    typeof(VersionRetriever).Assembly.GetName().Name,
                    typeof(VersionRetriever).FullName
                );

                return retriever.GetVersionFromAssembly(fileName);
            }
            finally
            {
                AppDomain.Unload(appDomain);
            }
        }

        public RecyclableAppDomain(string name, AppDomainSetup info)
        {
            domain = AppDomain.CreateDomain (name, null, info);

            //FIXME: do we want to allow resolving arbitrary MD assemblies?
            //domain.AssemblyResolve += new Mono.TextTemplating.CrossAppDomainAssemblyResolver ().Resolve;
        }

 public static AppDomain CreateAppDomain(string name, string pluginPath)
 {
     AppDomainSetup setup = new AppDomainSetup();
     setup.PrivateBinPath = pluginPath;
     AppDomain domain = AppDomain.CreateDomain(name, null, setup);
     return domain;
 }

 private RemotingTest GetRemoteTestObject()
 {
     var ads = new AppDomainSetup { ApplicationBase = AppDomain.CurrentDomain.BaseDirectory };
     var ad = AppDomain.CreateDomain("test", null, ads);
     var test = (RemotingTest)ad.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, "ReactiveTests.Tests.RemotingTest");
     return test;
 }

        public string FileSearchClient(int ID, string netP2pUri, string strFileSearchSNodeIp)
        {
            try
            {
                string httpUri = "http://" + strFileSearchSNodeIp + ":80/VMukti/FileSearch" + (objFileSearchDummies.Count + 1).ToString() + "/" + DateTime.Now.ToUniversalTime().Millisecond.ToString();
                AppDomainSetup setup = new AppDomainSetup();
                setup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;

                appDummyDomains.Add(AppDomain.CreateDomain("DummyFileSearch" + ID.ToString(), null, setup, new System.Security.PermissionSet(PermissionState.Unrestricted)));
                appDummyDomains[appDummyDomains.Count - 1].ApplicationTrust.ExtraInfo = AppDomain.CurrentDomain.ApplicationTrust.ExtraInfo;
                appDummyDomains[appDummyDomains.Count - 1].ApplicationTrust.DefaultGrantSet = new System.Security.Policy.PolicyStatement(new System.Security.PermissionSet(PermissionState.Unrestricted));
                appDummyDomains[appDummyDomains.Count - 1].ApplicationTrust.IsApplicationTrustedToRun = true;
                appDummyDomains[appDummyDomains.Count - 1].ApplicationTrust.Persist = true;
                objFileSearchDummies.Add(InstantiateFileSearch(appDummyDomains[appDummyDomains.Count - 1], new DomainBinder(), new CultureInfo("en-US"), UserName, "", ID, netP2pUri, httpUri));
                return httpUri;
            }
            catch (Exception ex)
            {
                VMuktiAPI.VMuktiHelper.ExceptionHandler(ex, "FileSearchClient", "DummyClient.cs");
                return null;
            }
            //appDummyDomains.Add(AppDomain.CreateDomain("DummyFileSearch" + ID.ToString(), null, setup));
            //objFileSearchDummies.Add(InstantiateFileSearch(appDummyDomains[appDummyDomains.Count - 1], new DomainBinder(), new CultureInfo("en-US"), UserName, "", ID, netP2pUri, httpUri));
            //return httpUri;
        }

        internal static string Transform(string xml, IAssemblyReferenceResolver resolver)
        {
            if (xml == null)
                throw new ArgumentNullException("xml");

            var setup = new AppDomainSetup
            {
                ApplicationBase = Path.GetDirectoryName(typeof(IsolatedResourceTransformer).Assembly.Location),
                ApplicationName = "Isolated Transformer"
            };

            var appDomain = AppDomain.CreateDomain(
                setup.ApplicationName,
                AppDomain.CurrentDomain.Evidence,
                setup
            );

            try
            {
                using (new AssemblyResolver())
                {
                    var transformer = (IsolatedResourceTransformer)appDomain.CreateInstanceAndUnwrap(
                        typeof(IsolatedResourceTransformer).Assembly.FullName,
                        typeof(IsolatedResourceTransformer).FullName
                    );

                    return transformer.PerformTransform(xml, resolver);
                }
            }
            finally
            {
                AppDomain.Unload(appDomain);
            }
        }

        public AppDomain createAppDomain(string appDomainName, AppDomainSetup appDomainSetup)
        {
            try
            {
                if (DI.appDomainsControledByO2Kernel.ContainsKey(appDomainName))
                    DI.log.error("in createAppDomain, appDomainName provided has already been used, appDomainNames must be unique: {0}", appDomainName);
                else
                {


                    DI.log.info("Creating AppDomain {0} with Base Directory {1}", appDomainName,
                                appDomainSetup.ApplicationBase);
                    // ensure target directory exits
                    O2Kernel_Files.checkIfDirectoryExistsAndCreateIfNot(appDomainSetup.ApplicationBase);

                    // give our appDomain full trust :)
                    var permissionSet = new PermissionSet(PermissionState.Unrestricted);

                    DI.appDomainsControledByO2Kernel.Add(appDomainName,this);
                    
                    //Create domain
                    appDomain = AppDomain.CreateDomain(appDomainName, null, appDomainSetup, permissionSet);
            //        appDomain.AssemblyResolve += new ResolveEventHandler(assemblyResolve);
                    BaseDirectory = appDomain.BaseDirectory;
                    return appDomain;
                }
            }
            catch (Exception ex)
            {
                DI.log.ex(ex, "could not load createAppDomain: " + appDomainName);
            }
            return null;
        }

        public void LoadFrom(string path)
        {
            if (_domain != null)
            {
                _scanner.Teardown();
                AppDomain.Unload(_domain);
            }

            var name = Path.GetFileNameWithoutExtension(path);
            var dirPath = Path.GetFullPath(Path.GetDirectoryName(path));

            var setup = new AppDomainSetup
            {
                ApplicationBase = AppDomain.CurrentDomain.BaseDirectory,
                PrivateBinPath = dirPath,
                ShadowCopyFiles = "true",
                ShadowCopyDirectories = dirPath,
            };

            _domain = AppDomain.CreateDomain(name + "Domain", AppDomain.CurrentDomain.Evidence, setup);

            var scannerType = typeof(Scanner);
            _scanner = (Scanner)_domain.CreateInstanceAndUnwrap(scannerType.Assembly.FullName, scannerType.FullName);
            _scanner.Load(name);
            _scanner.Setup();
        }

		public void ConfigurationFile_Absolute_NoApplicationBase ()
		{
			AppDomainSetup setup = new AppDomainSetup();
			string configFile = Path.GetFullPath("blar.config");
			setup.ConfigurationFile = configFile;
			Assert.AreEqual(configFile, setup.ConfigurationFile);
		}