public static void LoadPackages(Action<IPackageFacility> configuration, bool runActivators = true)
        {
            _packages.Clear();

            Diagnostics = new PackagingDiagnostics();
            var record = new PackageLoadingRecord();

            Diagnostics.LogExecution(record, () =>
            {
                var facility = new PackageFacility();
                var assemblyLoader = new AssemblyLoader(Diagnostics);
                var graph = new PackagingRuntimeGraph(Diagnostics, assemblyLoader, _packages);

                var codeLocation = findCallToLoadPackages();
                graph.PushProvenance(codeLocation);
                configuration(facility);
                facility.Configure(graph);


                graph.PopProvenance();
                graph.DiscoverAndLoadPackages(() =>
                {
                    _assemblies.Clear();
                    _assemblies.AddRange(assemblyLoader.Assemblies);
                }, runActivators);
            });

            record.Finished = DateTime.Now;

            //_packages.Clear();


        }

        public void Loader_returns_null_if_assembly_is_not_found_at_path()
        {
            var assemblyLoader = new AssemblyLoader();
            var assembly = assemblyLoader.LoadAssembly(@"c:\a\non\existent\path\assembly.dll");

            Assert.That(assembly, Is.Null);
        }

 public PluginContainerBuilder(AssemblyLoader assemblyLoader, IPluginJudge pluginJudge, IContainerFactory containerFactory, ILogger logger)
 {
     _assemblyLoader = assemblyLoader;
     _pluginJudge = pluginJudge;
     _containerFactory = containerFactory;
     _logger = logger;
 }

 /// <summary>Initialises the assembly loader.</summary>
 internal static void Init()
 {
     if (instance == null)
     {
         instance = new AssemblyLoader();
     }
 }

        public void Run()
        {
            var assemblyLoader = new AssemblyLoader(this.assemblyPath);
            var assembly = assemblyLoader.Assembly;

            var testMethodLoader = new TestMethodLoader(assembly);
            var testContainers = testMethodLoader.LoadTestMethods();
            foreach (var testContainer in testContainers)
            {
                var instance = Activator.CreateInstance(testContainer.Key);
                var testMethods = testContainer.Value;
                foreach (MethodInfo testMethod in testMethods)
                {
                    var testType = this.GetTestType(testMethod);

                    var testRunner = TestRunnerFactory.GetTestRunner(
                        testType,
                        testMethod,
                        instance);

                    testRunner.RunTest();
                    this.LogTestResult(testRunner, testMethod);
                }
            }
        }

        public void Load_NullOrEmptyPath_ReturnsNull(string path)
        {
            var subject = new AssemblyLoader(path);
            var result = subject.Load();

            Assert.AreEqual(null, result);
        }

        //parameterParsers are classes that extends from IExternalConstructor
        public ClassHierarchyImpl(string[] assemblies, Type[] parameterParsers)  
        {
            this.assemblies = assemblies;
            rootNode = NodeFactory.CreateRootPackageNode();
            loader = new AssemblyLoader(assemblies);
           
            foreach (Type p in parameterParsers) //p must be extend from IExternalConstructor
            {
                try 
                {
                    Parameterparser.AddParser(p);
                } 
                catch (BindException e)
                {
                    Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
                    Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ArgumentException("Could not register parameter parsers", e), LOGGER);
                }
            }

            foreach (var a in loader.Assemblies)
            {
                foreach (var t in a.GetTypes())
                {
                    RegisterType(t);
                }
            }
        }

        public static void RunTests()
        {
            var loader = new AssemblyLoader();
            var testMethods = loader.GatherTests();

            Console.LogDateTime = true;

            foreach (var untypedTest in testMethods)
            {
                var methodInfo = (MethodInfo)untypedTest;

                try
                {
                    methodInfo.Invoke(null, null);
                    Console.WriteLine(methodInfo.DeclaringType + "." + methodInfo.Name + " - Passed.");
                }
                catch(ControlledAssertionException controlledAssertionException)
                {
                    Log(methodInfo, controlledAssertionException.Message);
                }
                catch (Exception ex)
                {
                    Log(methodInfo, "Failed", ex);
                }
            }

            Console.WriteLine("End of test run.");
        }

 public TestRunner(Logger output, AssemblyLoader assemblyLoader)
 {
     AllPassed = true;
     this.output = output;
     this.assemblyLoader = assemblyLoader;
     processor = new StepProcessor(this);
 }

        public static void Main()
        {
            var loader = new AssemblyLoader();

            var plugin = loader.LoadPlugInAppDomain("Plug.dll");

            plugin.Delay(TimeSpan.FromSeconds(2)).Subscribe(x => Console.WriteLine("Delayed: " + x));
            var isTrue = true;

            while (isTrue)
            {
                var text = Console.ReadLine();

                plugin.Push(text);

                if (string.IsNullOrEmpty(text))
                    isTrue = false;
            }

            plugin.Dispose();

            Console.WriteLine("Plugin disposed.");

            Console.ReadLine();
        }

        public OperationExecutor(
            [NotNull] CommonOptions options,
            [CanBeNull] string environment)
        {
            var projectFile = Path.Combine(Directory.GetCurrentDirectory(), Project.FileName);
            var project = ProjectReader.GetProject(projectFile);

            var projectConfiguration = options.Configuration ?? Constants.DefaultConfiguration;
            var projectFramework = options.Framework;

            var projectContext = ProjectContext.Create(project.ProjectFilePath,
                projectFramework,
                RuntimeEnvironmentRidExtensions.GetAllCandidateRuntimeIdentifiers());

            var runtimeOutputPath = projectContext.GetOutputPaths(projectConfiguration)?.RuntimeOutputPath;
            if (!string.IsNullOrEmpty(runtimeOutputPath))
            {
                Reporter.Verbose.WriteLine(
                    ToolsCliStrings.LogDataDirectory(runtimeOutputPath));
                Environment.SetEnvironmentVariable(DataDirEnvName, runtimeOutputPath);
#if NET451
                AppDomain.CurrentDomain.SetData("DataDirectory", runtimeOutputPath);
#endif
            }

            var assemblyName = project.GetCompilerOptions(projectFramework, projectConfiguration).OutputName;
            var projectDir = project.ProjectDirectory;
            var rootNamespace = project.Name;

            var assemblyLoader = new AssemblyLoader(Assembly.Load);
            var projectAssembly = assemblyLoader.Load(assemblyName);

            _contextOperations = new LazyRef<DbContextOperations>(
                          () => new DbContextOperations(
                              new LoggerProvider(name => new ConsoleCommandLogger(name)),
                              projectAssembly,
                              projectAssembly,
                              environment,
                              projectDir));
            _databaseOperations = new LazyRef<DatabaseOperations>(
                () => new DatabaseOperations(
                    new LoggerProvider(name => new ConsoleCommandLogger(name)),
                    assemblyLoader,
                    projectAssembly,
                    environment,
                    projectDir,
                    projectDir,
                    rootNamespace));
            _migrationsOperations = new LazyRef<MigrationsOperations>(
                () => new MigrationsOperations(
                    new LoggerProvider(name => new ConsoleCommandLogger(name)),
                    projectAssembly,
                    assemblyLoader,
                    projectAssembly,
                    environment,
                    projectDir,
                    projectDir,
                    rootNamespace));
        }

 internal PackageInstaller(IFileSystem fileSystem, AssemblyLoader assemblyLoader)
 {
     _fileSystem = fileSystem;
     _assemblyLoader = assemblyLoader;
     _currentFramework = GetCurrentFramework();
     _settings = Settings.LoadDefaultSettings(fileSystem.RootPath.FullPath, null, new MachineWideSettings());
     _sourceRepositories = new SourceRepositoryProvider(_settings);
 }

 public static FrameworkAdapter Try(AssemblyLoader assemblyLoader) {
    foreach (var assemblyName in assemblyLoader.GetReferencedAssemblies()) {
       if (assemblyName.FullName.ToLower().Contains("nunit.framework,")) {
          return new NUnitAdapter();
       }
    }
    return null;
 }

 public static FrameworkAdapter Try(AssemblyLoader assemblyLoader) {
    foreach (var assemblyName in assemblyLoader.GetReferencedAssemblies()) {
       if (assemblyName.FullName.Contains("Microsoft.VisualStudio.QualityTools.UnitTestFramework,")) {
          return new MsUnitTestAdapter();
       }
    }
    return null;
 }

        public void AssemblyLoaderMustLoadTargetAssemblyFromDisk()
        {
            IAssemblyLoader loader = new AssemblyLoader();

            // The loader should return a valid assembly
            Assembly result = loader.Load(typeof(SampleClass).Assembly.Location);
            Assert.IsNotNull(result);
        }

 public void ShouldBeAbleToGetTypes()
 {
     var assemblyLoader = new AssemblyLoader();
     var types = assemblyLoader.GetTypes(@"C:\Source\Mike.AmqpSpike\EasyNetQ.Tests.Messages\bin\Debug\EasyNetQ.Tests.Messages.dll");
     foreach (var type in types)
     {
         Console.WriteLine(type);
     }
 }

        static void Main(string[] args)
        {
            var arguments = ParseCommandLine(args);

            var loader = new AssemblyLoader();
            var dbProvider = loader.CreateTypeFromAssembly<DbProvider>(arguments["dbp.provider"], arguments);
            var dbCodeFormatter = loader.CreateTypeFromAssembly<DbTraceCodeFormatter>(arguments["tcf.provider"], arguments);
            var codeHighlighter = loader.CreateTypeFromAssembly<HighlightCodeProvider>(arguments["hcp.provider"], arguments);
            var outputProvider = loader.CreateTypeFromAssembly<OutputProvider>(arguments["out.provider"], arguments);

            var command = arguments["app.command"].ToLower().Trim();

            // Get trace name from provided, last trace, or generate one.
            string traceName = null;
            if (arguments.ContainsKey("app.traceName"))
            {
                traceName = arguments["app.traceName"];
            }
            if (traceName == null && command != "start")
            {
                traceName = dbProvider.GetLastTraceName();
            }
            else if (traceName == null && command == "start")
            {
                traceName = DateTime.Now.ToString("yyyyMMddHHmmss");
            }

            // Get the specific database object name to run against, if specified (mainly used for testing).
            if (arguments.ContainsKey("test.objectname"))
            {
                var objectName = arguments["test.objectname"];
                dbProvider.SetSpecificObjectNameForTesting(objectName);
            }

            switch (command)
            {
                case "generate":
                    var generateCommand = new GenerateOutputCommand(dbProvider, dbCodeFormatter, codeHighlighter, outputProvider, traceName);
                    generateCommand.Execute();
                    break;

                case "start":
                    var startCommand = new StartCommand(outputProvider, dbProvider, traceName);
                    startCommand.Execute();
                    break;

                case "stop":
                    var stopCommand = new StopCommand(dbProvider, outputProvider, traceName);
                    stopCommand.Execute();
                    break;

                case "finish":
                    new GenerateOutputCommand(dbProvider, dbCodeFormatter, codeHighlighter, outputProvider, traceName).Execute();
                    new StopCommand(dbProvider, outputProvider, traceName).Execute();
                    break;
            }
        }

        static void Main(string[] args)
        {
            var arguments = new Dictionary<string, string>();

             // App.Config Settings
             var appSettingKeys = ConfigurationManager.AppSettings.Keys;
             for (var i = 0; i < appSettingKeys.Count; i++)
             {
            var key = appSettingKeys[i];
            arguments.AddOrUpdate(key, ConfigurationManager.AppSettings[key]);
             }

             // Manual override through CLI.
             var p = new OptionSet()
                    {
                       {
                          "<>", v =>
                                   {
                                      if (!v.StartsWith("--"))
                                         return;
                                      var split = v.Split(new[] { '=' }, 2);
                                      if (split.Length != 2)
                                         return;
                                      arguments.AddOrUpdate(split[0].TrimStart('-'), split[1]);
                                   }
                          }
                    };

             p.Parse(args);

             var loader = new AssemblyLoader();
             var dbProvider = loader.CreateTypeFromAssembly<DbProvider>(arguments["dbp.provider"], arguments);
             var dbCodeFormatter = loader.CreateTypeFromAssembly<DbTraceCodeFormatter>(arguments["tcf.provider"], arguments);
             var codeHighlighter = loader.CreateTypeFromAssembly<HighlightCodeProvider>(arguments["hcp.provider"], arguments);
             var outputProvider = loader.CreateTypeFromAssembly<OutputProvider>(arguments["out.provider"], arguments);

             switch (arguments["app.mode"].ToLower().Trim())
             {
            case "generate":
               var generateCommand = new GenerateOutputCommand(dbProvider, dbCodeFormatter, codeHighlighter, outputProvider, arguments["app.traceName"]);
               generateCommand.Execute();
               break;

            case "start":
               var startCommand = new StartCommand(outputProvider, dbProvider, arguments["app.traceName"]);
               startCommand.Execute();
               break;

            case "stop":
               {
                  var stopCommand = new StopCommand(dbProvider, outputProvider, arguments["app.traceName"]);
                  stopCommand.Execute();
               }
               break;
             }
        }

        public void Load_LoadsAssemblyFromExecutingDirectoryWhenOnlyTheAssemblyFileNameIsProvided()
        {
            var expected = GetType().Assembly;

            var sut = new AssemblyLoader(() => expected.GetName().Name + ".dll");

            var actual = sut.Load();

            Assert.Equal(expected, actual);
        }

        public void Load_LoadsAssemblyFromFile()
        {
            var expected = GetType().Assembly;

            var sut = new AssemblyLoader(() => expected.Location);

            var actual = sut.Load();

            Assert.Equal(expected, actual);
        }