public void ShouldOnlyReturnBinariesWhenFlagIsSet(
                [Frozen] Mock<IPackageAssemblyResolver> packageAssemblyResolverMock, 
                [Frozen] Mock<IFileSystem> fileSystemMock, 
                [Frozen] Mock<IAssemblyUtility> assemblyUtilityMock,
                AssemblyResolver resolver)
            {
                const string WorkingDirectory = @"C:\";

                var binFolder = Path.Combine(WorkingDirectory, "bin");

                assemblyUtilityMock.Setup(a => a.IsManagedAssembly(It.IsAny<string>())).Returns(true);
                fileSystemMock.Setup(x => x.DirectoryExists(binFolder)).Returns(true);
                fileSystemMock.Setup(x => x.DirectoryExists(@"C:\packages")).Returns(true);
                fileSystemMock.SetupGet(x => x.PackagesFolder).Returns("packages");
                fileSystemMock.SetupGet(x => x.BinFolder).Returns("bin");
                fileSystemMock.Setup(x => x.EnumerateFiles(binFolder, It.IsAny<string>(), SearchOption.AllDirectories))
                    .Returns(Enumerable.Empty<string>());

                packageAssemblyResolverMock.Setup(p=>p.GetAssemblyNames(WorkingDirectory)).Returns(new string[] {"test.dll", "test.exe", "test.foo"});

                var assemblies = resolver.GetAssemblyPaths(WorkingDirectory, true).ToList();
                assemblies.ShouldNotContain("test.foo");
                assemblies.ShouldContain("test.dll");
                assemblies.ShouldContain("test.exe");
            }

            public void ShouldNotReturnNonManagedAssemblies(
                [Frozen] Mock<IFileSystem> fileSystemMock,
                [Frozen] Mock<IPackageAssemblyResolver> packageAssemblyResolverMock,
                [Frozen] Mock<IAssemblyUtility> assemblyUtilityMock,
                AssemblyResolver resolver
            )
            {
                const string WorkingDirectory = @"C:\";

                var binFolder = Path.Combine(WorkingDirectory, "bin");
                var managed = Path.Combine(binFolder, "MyAssembly.dll");
                var nonManaged = Path.Combine(binFolder, "MyNonManagedAssembly.dll");

                fileSystemMock.Setup(x => x.DirectoryExists(binFolder)).Returns(true);
                fileSystemMock.SetupGet(x => x.PackagesFolder).Returns("packages");
                fileSystemMock.SetupGet(x => x.BinFolder).Returns("bin");
                fileSystemMock.Setup(x => x.EnumerateFiles(binFolder, It.IsAny<string>(), SearchOption.TopDirectoryOnly
                    ))
                    .Returns(new[] { managed, nonManaged });

                assemblyUtilityMock.Setup(x => x.IsManagedAssembly(managed)).Returns(true);
                assemblyUtilityMock.Setup(x => x.IsManagedAssembly(nonManaged)).Returns(false);

                var assemblies = resolver.GetAssemblyPaths(WorkingDirectory).ToList();

                assemblies.Count.ShouldEqual(1);
                assemblies[0].ShouldEqual(managed);
            }

 public AssemblyLoaderImporter(ModuleReader moduleReader, AssemblyResolver assemblyResolver, EmbedTask embedTask)
 {
     instructionConstructorInfo = typeof (Instruction).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new[] {typeof (OpCode), typeof (object)}, null);
     this.moduleReader = moduleReader;
     this.assemblyResolver = assemblyResolver;
     this.embedTask = embedTask;
 }

 public void Should_exception_if_type_not_found()
 {
     var job = new PrivateJob { Type = "someType" };
     assemblyResolver = new AssemblyResolver(this.dir, log);
     //Test
     var ex = Assert.Throws<PluginNotFoundOrLoadedException>(() => assemblyResolver.ResolveType(job));
     //Assert
     Assert.That(ex.Message, Is.EqualTo(string.Format("The plugin someType is not found or loaded")));
 }

        public void DefaultResolve()
        {

            var resolver = new AssemblyResolver();
            resolver.Should().NotBeNull();

            var assemblies = resolver.Resolve().ToList();
            assemblies.Should().NotBeEmpty();
            assemblies.Should().Contain(a => a.FullName.StartsWith("System"));

        }

        public void IncludeAssemblyForTestCore()
        {
            var resolver = new AssemblyResolver();
            resolver.Should().NotBeNull();

            resolver.IncludeAssemblyFor<SampleWorker>();

            var assemblies = resolver.Resolve().ToList();
            assemblies.Should().NotBeEmpty();
            assemblies.Count.Should().Be(1);
            assemblies.Should().Contain(a => a == typeof(SampleWorker).Assembly);
        }

 public void Should_Resolve_type_sucessfuly()
 {
     var job = new WmiClient();
     var files = new List<string>() { string.Format(@"{0}\SqlToGraphite.Plugin.Wmi.dll", Directory.GetCurrentDirectory()) };
     dir.Expect(x => x.GetFilesInCurrentDirectory(AssemblyResolver.FilesToScan)).Return(files);
     //Test
     assemblyResolver = new AssemblyResolver(this.dir, log);
     var rtn = assemblyResolver.ResolveType(job);
     //Assert
     Assert.That(rtn.FullName, Is.EqualTo(job.GetType().FullName));
     dir.VerifyAllExpectations();
 }

        public void CreateAssemblyResolver(IEnumerable<string> paths)
        {
            string appDataKey = typeof (AssemblyResolver).FullName;
            resolver = (AssemblyResolver)AppDomain.CurrentDomain.GetData(appDataKey)
                       ?? new AssemblyResolver(new ConsoleLog());
            AppDomain.CurrentDomain.SetData(appDataKey, resolver);

            foreach (var path in paths)
            {
                resolver.AddDirectory(path);
            }
        }

        public void ExcludeSystem()
        {
            var domainAssemblies = AppDomain.CurrentDomain.GetAssemblies();

            var resolver = new AssemblyResolver();
            resolver.Should().NotBeNull();

            resolver.ExcludeName("System");

            var assemblies = resolver.Resolve().ToList();
            assemblies.Should().NotBeEmpty();
            assemblies.Should().NotContain(a => a.FullName.StartsWith("System"));
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Configuration"/> class.
        /// </summary>
        public Configuration()
        {
            _assemblies = new AssemblyResolver();

            // exclude system assemblies
            _assemblies.ExcludeName("mscorlib");
            _assemblies.ExcludeName("Microsoft");
            _assemblies.ExcludeName("System");
            
            // exclude self
            _assemblies.ExcludeName("KickStart");

            _starters = new List<IKickStarter>();
        }

 public void Should_ignore_bad_image_exception_for_not_dot_net_dlls()
 {
     File.WriteAllText("bad.dll", "abc");
     var job = new WmiClient() { Type = "SqlToGraphite.Plugin.Wmi.WmiClient" };
     var files = new List<string>() { string.Format(@"{0}\bad.dll", Directory.GetCurrentDirectory()), string.Format(@"{0}\SqlToGraphite.Plugin.Wmi.dll", Directory.GetCurrentDirectory()) };
     dir.Expect(x => x.GetFilesInCurrentDirectory(AssemblyResolver.FilesToScan)).Return(files);
     //Test
     assemblyResolver = new AssemblyResolver(this.dir, log);
     //Test
     var type = assemblyResolver.ResolveType(job);
     //Assert
     Assert.That(type.FullName, Is.EqualTo(job.GetType().FullName));
     File.Delete("bad.dll");
 }

        public SqlToGraphiteConfig()
        {
            var job = new JobImpl();
            this.WireUpLog4Net();
            var assemblyResolver = new AssemblyResolver(new DirectoryImpl(), log);
            jobTypes = assemblyResolver.ResolveTypes(job);
            alljobtypes = assemblyResolver.ResolveAllTypes(job);
            //JobTypes = GetJobTypes().ToArray();
            clientTypes = GetClientTypes().ToArray();

            this.Jobs = new List<Job>();
            this.Clients = new ListOfUniqueType<Client>();
            this.Hosts = new List<Host>();
            this.Templates = new List<Template>();
            this.genericSerializer = new GenericSerializer(Global.GetNameSpace());
        }

        public CompilerBase(
            IFrontEnd frontEnd, IMiddleEnd middleEnd, IBackEnd backEnd,
            CompilerOptions options
            )
        {
            _options = options;

            _frontEnd = frontEnd;
            _middleEnd = middleEnd;
            _backEnd = backEnd;

            _frontEnd.Compiler = this;
            _middleEnd.Compiler = this;
            _backEnd.Compiler = this;

            _resolver = new AssemblyResolver(this);
        }

 public ConfigRepository(IConfigReader configReader, ICache cache, ISleep sleep, ILog log,
     int errorReadingConfigSleepTime, IGenericSerializer genericSerializer)
 {
     this.configReader = configReader;
     this.cache = cache;
     this.sleep = sleep;
     ConfigRepository.log = log;
     this.errorReadingConfigSleepTime = errorReadingConfigSleepTime;
     this.genericSerializer = genericSerializer;
     clientList = new GraphiteClients();
     var dir = new DirectoryImpl();
     if (ar == null)
     {
         ar = new AssemblyResolver(dir, log);
     }
     this.masterConfig = new SqlToGraphiteConfig(ar, log);
     this.Hash = "NotSet";
 }

		void Find() {
			var cflowDeobfuscator = new CflowDeobfuscator(new MethodCallInliner(true));

			foreach (var type in module.Types) {
				if (DotNetUtils.GetPInvokeMethod(type, "kernel32", "CloseHandle") == null)
					continue;

				var resolver = new AssemblyResolver(type, cflowDeobfuscator);
				if (!resolver.Detected)
					continue;
				var patcher = new MemoryPatcher(type, cflowDeobfuscator);
				if (!patcher.Detected)
					continue;

				assemblyResolver = resolver;
				memoryPatcher = patcher;
				return;
			}
		}

            public void ShouldReturnAssembliesFromPackagesFolder()
            {
                const string WorkingDirectory = @"C:\";

                var packagesFolder = Path.Combine(WorkingDirectory, Constants.PackagesFolder);
                var assemblyFile = Path.Combine(packagesFolder, "MyAssembly.dll");

                var fileSystem = new Mock<IFileSystem>();
                fileSystem.Setup(x => x.DirectoryExists(packagesFolder)).Returns(true);

                var packageAssemblyResolver = new Mock<IPackageAssemblyResolver>();
                packageAssemblyResolver.Setup(x => x.GetAssemblyNames(WorkingDirectory, It.IsAny<Action<string>>())).Returns(new[] { assemblyFile });

                var resolver = new AssemblyResolver(fileSystem.Object, packageAssemblyResolver.Object, Mock.Of<IAssemblyUtility>(), Mock.Of<ILog>());

                var assemblies = resolver.GetAssemblyPaths(WorkingDirectory).ToList();

                assemblies.Count.ShouldEqual(1);
                assemblies[0].ShouldEqual(assemblyFile);
            }

            public void ShouldNotReturnScriptDll()
            {
                const string WorkingDirectory = @"C:\";

                var binFolder = Path.Combine(WorkingDirectory, "bin");
                var scriptDll = Path.Combine(binFolder, "script.dll");

                var fileSystem = new Mock<IFileSystem>();
                fileSystem.Setup(x => x.DirectoryExists(binFolder)).Returns(true);
                fileSystem.Setup(x => x.EnumerateFiles(binFolder, It.IsAny<string>(), SearchOption.AllDirectories))
                    .Returns(new[] { scriptDll });

                var assemblyUtility = new Mock<IAssemblyUtility>();
                assemblyUtility.Setup(x => x.IsManagedAssembly(scriptDll)).Returns(true);

                var resolver = new AssemblyResolver(fileSystem.Object, Mock.Of<IPackageAssemblyResolver>(), assemblyUtility.Object, Mock.Of<ILog>());

                var assemblies = resolver.GetAssemblyPaths(WorkingDirectory, "script.csx").ToList();

                assemblies.Count.ShouldEqual(0);
            }

            public void ShouldReturnAssembliesFromBinFolder()
            {
                const string WorkingDirectory = @"C:\";

                var binFolder = Path.Combine(WorkingDirectory, Constants.BinFolder);
                var assemblyFile = Path.Combine(binFolder, "MyAssembly.dll");

                var fileSystem = new Mock<IFileSystem>();
                fileSystem.Setup(x => x.DirectoryExists(binFolder)).Returns(true);
                fileSystem.Setup(x => x.EnumerateFiles(binFolder, It.IsAny<string>(), SearchOption.AllDirectories)).Returns(new[] { assemblyFile });

                var assemblyUtility = new Mock<IAssemblyUtility>();
                assemblyUtility.Setup(x => x.IsManagedAssembly(assemblyFile)).Returns(true);

                var resolver = new AssemblyResolver(fileSystem.Object, Mock.Of<IPackageAssemblyResolver>(), assemblyUtility.Object, Mock.Of<ILog>());

                var assemblies = resolver.GetAssemblyPaths(WorkingDirectory).ToList();

                assemblies.Count.ShouldEqual(1);
                assemblies[0].ShouldEqual(assemblyFile);
            }

        public static TaskManager CreateTaskManager(SqlToGraphiteSection configuration)
        {
            var cacheLength = new TimeSpan(0, configuration.ConfigCacheLengthMinutes, 0);
            var stop = new Stop();
            var directoryImpl = new DirectoryImpl();
            var assemblyResolver = new AssemblyResolver(directoryImpl, log);
            IEncryption encryption = new Encryption();
            IDataClientFactory dataClientFactory = new DataClientFactory(log, assemblyResolver, encryption);
            IGraphiteClientFactory graphiteClientFactory = new GraphiteClientFactory(log);

            var configReader = new ConfigHttpReader(configuration.ConfigUri, configuration.ConfigUsername, configuration.ConfigPassword);
            var cache = new Cache(cacheLength, log);
            var sleeper = new Sleeper();
            var genericSer = new GenericSerializer(Global.GetNameSpace());
            var cr = new ConfigRepository(configReader, cache, sleeper, log, configuration.MinutesBetweenRetryToGetConfigOnError, genericSer);
            var configMapper = new ConfigMapper(configuration.Hostname, stop, dataClientFactory, graphiteClientFactory, log, cr);
            var roleConfigFactory = new RoleConfigFactory();
            var environment = new Environment();
            var taskSetBuilder = new TaskSetBuilder();
            var configController = new ConfigController(configMapper, log, cr, roleConfigFactory, environment, taskSetBuilder);
            return new TaskManager(log, configController, configuration.ConfigUri, stop, sleeper, configuration.CheckConfigUpdatedEveryMinutes);
        }

            public void ShouldReturnAssembliesFromPackagesFolder(
                [Frozen] Mock<IFileSystem> fileSystemMock,
                [Frozen] Mock<IPackageAssemblyResolver> packageAssemblyResolverMock,
                AssemblyResolver resolver
            )
            {
                const string WorkingDirectory = @"C:\";

                var packagesFolder = Path.Combine(WorkingDirectory, "packages");
                var assemblyFile = Path.Combine(packagesFolder, "MyAssembly.dll");

                fileSystemMock.Setup(x => x.DirectoryExists(packagesFolder)).Returns(true);
                fileSystemMock.SetupGet(x => x.PackagesFolder).Returns("packages");
                fileSystemMock.SetupGet(x => x.BinFolder).Returns("bin");

                packageAssemblyResolverMock.Setup(x => x.GetAssemblyNames(WorkingDirectory)).Returns(new[] { assemblyFile });

                var assemblies = resolver.GetAssemblyPaths(WorkingDirectory).ToList();

                assemblies.Count.ShouldEqual(1);
                assemblies[0].ShouldEqual(assemblyFile);
            }