public void InitializeThrowsBadImageExceptionOnInvalidInputImage() { CecilAnalyzerConfiguration configuration = CecilAnalyzerConfiguration.CreateDefaultConfiguration(string.Empty); ILanguageModelAccessor langModelAccessor = new LanguageModelAccessorMock(); AssemblyElement ae = ((IILAnalyzer) new CecilILAnalyzer(configuration, langModelAccessor)).ExtractAllTypes(CreateFullPath("InvalidImage.exe")); }
public void AnalyzerThrowsExceptionIfFileDoesntExists() { CecilAnalyzerConfiguration configuration = CecilAnalyzerConfiguration.CreateDefaultConfiguration(string.Empty); ILanguageModelAccessor langModelAccessor = new LanguageModelAccessorMock(); AssemblyElement ae = ((IILAnalyzer) new CecilILAnalyzer(configuration, langModelAccessor)).ExtractAllTypes("c:\\this_file_doesnt_exist"); }
/// <summary> /// Executes the ILAnalyser task. /// </summary> /// <returns> /// <c>true</c> if the task successfully executed; otherwise, <c>false</c>. /// </returns> public override bool Execute() { base.Execute(); Log.LogMessageFromResources("AnalyzerStartText"); // // Setup of configuration and lists // IEntitiesAccessor entitiesAccessor = EntitiesAccessor.Instance; CecilAnalyzerConfiguration configuration = new CecilAnalyzerConfiguration(_repositoryFileName); configuration.BinFolder = _binFolder; configuration.DoMethodCallAnalysis = _doMethodCallAnalysis; // Initialize instance variables _configContainer = entitiesAccessor.LoadConfiguration(_repositoryFileName); _filterActions = _configContainer.FilterActions; _filterTypes = _configContainer.FilterTypes; _resources = _configContainer.Resources; _conflictRules = _configContainer.ConflictRules; _assembliesInConfig = _configContainer.Assemblies; _assembliesToStore = new List <AssemblyConfig>(); // Create the analyzer using the object builder using (IILAnalyzer analyzer = DIHelper.CreateObject <CecilILAnalyzer>(CreateContainer(entitiesAccessor, configuration))) { // Find the assemblies to analyze List <ITaskItem> weavableAssemblies = FindAssembliesToAnalyze(); List <ITaskItem> refAssemblies = FindReferencedAssemblies(); // Add all the unresolved types (used in the concern files) to the analyser AddUnresolvedTypes(analyzer); // Create a list to store information about analyzed assemblies in List <AssemblyElement> assemblies = new List <AssemblyElement>(); // Analyze the assemblies in the output folder AnalyzeWeavableAssemblies(analyzer, weavableAssemblies, assemblies); // Analyze the assemblies referenced to this project or subprojects AnalyzeReferencedAssemblies(analyzer, refAssemblies, assemblies); // Store the found assemblies in the configuration container StoreAssemblies(analyzer); } return(!Log.HasLoggedErrors); }
public void TestTargetMustReturnCorrectAssembly() { // set up model LanguageModelAccessorMock model = new LanguageModelAccessorMock(); // create configuration CecilAnalyzerConfiguration configuration = CecilAnalyzerConfiguration.CreateDefaultConfiguration(string.Empty); // do weaving IILAnalyzer analyzer = DIHelper.CreateObject <CecilILAnalyzer>(CreateTestContainer(model, configuration)); AssemblyElement ae = analyzer.ExtractAllTypes(CreateFullPath("TestTarget.exe")); Assert.IsNotNull(ae, "Could not create an AssemblyElement."); Assert.IsFalse(string.IsNullOrEmpty(ae.FileName), "Filename is not set."); Assert.IsFalse(string.IsNullOrEmpty(ae.Name), "Assembly name is not set."); Assert.IsFalse(ae.Timestamp == 0, "Timestamp is not set."); Assert.IsTrue(ae.TypeElements.Length > 0, "TypeElements were not retrieved."); Assert.IsTrue(ae.TypeElements.Length == 1, "Found {0} TypeElements, expecting 1.", ae.TypeElements.Length); TypeElement te = ae.TypeElements[0]; Assert.IsNotNull(te, "Could not set the TypeElement."); Assert.IsFalse(string.IsNullOrEmpty(te.BaseType), "BaseType has not been stored."); Assert.IsFalse(string.IsNullOrEmpty(te.FullName), "FullName has not been stored."); Assert.IsFalse(string.IsNullOrEmpty(te.Name), "Name has not been stored."); Assert.IsFalse(string.IsNullOrEmpty(te.Namespace), "Namespace has not been stored."); Assert.IsTrue(te.MethodElements.Length == 2, "Methods not stored in the TypeElement. {0} methods found", te.MethodElements.Length); MethodElement me = te.MethodElements[0]; Assert.IsNotNull(me, "Could not set the methodElement"); Assert.IsFalse(string.IsNullOrEmpty(me.Name), "Name has not been stored."); Assert.IsFalse(string.IsNullOrEmpty(me.ReturnType), "Returntype has not been stored."); Assert.IsFalse(string.IsNullOrEmpty(me.Signature), "Signature has not been stored."); } // TestTargetMustReturnAssembly()
/// <summary> /// Creates the test container. /// </summary> /// <param name="languageModel">The language model.</param> /// <param name="configuration">The configuration.</param> /// <returns></returns> internal IServiceProvider CreateTestContainer(LanguageModelAccessorMock languageModel, CecilAnalyzerConfiguration configuration) { ServiceContainer serviceContainer = new ServiceContainer(); serviceContainer.AddService(typeof(IEntitiesAccessor), languageModel == null ? new LanguageModelAccessorMock() : languageModel); serviceContainer.AddService(typeof(CecilAnalyzerConfiguration), configuration == null ? CecilAnalyzerConfiguration.CreateDefaultConfiguration(CreateFullPath("test.yap")) : configuration); serviceContainer.AddService(typeof(IBuilderConfigurator <BuilderStage>), new ILAnalyzerTestBuilderConfigurator()); return(serviceContainer); }
private AssemblyInfo AnalyzeFile(String file) { AssemblyInfo result = new AssemblyInfo(); IEntitiesAccessor entitiesAccessor = null; try { entitiesAccessor = EntitiesAccessor.Instance; CecilAnalyzerConfiguration configuration = new CecilAnalyzerConfiguration(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "starlight.yap")); NameValueCollection config = new NameValueCollection(); config.Add("ProcessMethodBody", "true"); analyzer = DIHelper.CreateObject <CecilILAnalyzer>(CreateContainer(entitiesAccessor, configuration)); System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); AssemblyElement assembly = analyzer.ExtractAllTypes(file); sw.Stop(); // Create statistics int fields = 0; int methods = 0; int parameters = 0; int methodcalls = 0; int attributes = 0; foreach (TypeElement te in assembly.Types) { fields += te.Fields.Count; methods += te.Methods.Count; foreach (MethodElement me in te.Methods) { parameters += me.Parameters.Count; if (me.HasMethodBody && me.Body.Calls != null) { methodcalls += me.Body.Calls.Count; } } } result.TypeCount = assembly.Types.Count; result.FieldCount = fields; result.MethodCount = methods; result.ParameterCount = parameters; result.MethodCallCount = methodcalls; result.ElapsedTime = sw.Elapsed.TotalMilliseconds; result.UnresolvedTypes = analyzer.UnresolvedTypes.Count; sw.Reset(); List <AssemblyElement> assemblies = new List <AssemblyElement>(); assemblies.Add(assembly); if (analyzer.UnresolvedTypes.Count > 0 && resolve) { // Console.WriteLine("Processing {0} unresolved types...", analyzer.UnresolvedTypes.Count); foreach (String ut in analyzer.UnresolvedTypes) { Console.WriteLine(" {0}", ut); } if (analyzer.UnresolvedTypes.Count > 0) { foreach (String ut in analyzer.UnresolvedTypes) { Console.WriteLine(" {0}", ut); } } } } finally { analyzer.Dispose(); } return(result); }
/// <summary> /// Creates the services container. /// </summary> /// <param name="languageModel">The language model.</param> /// <param name="configuration">The configuration.</param> /// <returns></returns> internal static IServiceProvider CreateContainer(IEntitiesAccessor languageModel, CecilAnalyzerConfiguration configuration) { ServiceContainer serviceContainer = new ServiceContainer(); serviceContainer.AddService(typeof(IEntitiesAccessor), languageModel); serviceContainer.AddService(typeof(CecilAnalyzerConfiguration), configuration); return(serviceContainer); }
public void TestInitialize() { svcContainer.AddService(typeof(IBuilderConfigurator <BuilderStage>), new ILAnalyzerTestBuilderConfigurator()); svcContainer.AddService(typeof(CecilAnalyzerConfiguration), CecilAnalyzerConfiguration.CreateDefaultConfiguration(CreateFullPath("TestTarget.exe"))); svcContainer.AddService(typeof(ILanguageModelAccessor), new LanguageModelAccessorMock()); }
public virtual void GlobalSetUp() { config = CecilAnalyzerConfiguration.CreateDefaultConfiguration("test.yap"); }
/// <summary> /// Analyzes the referenced assemblies. /// </summary> /// <param name="analyzer">The analyzer.</param> /// <param name="refAssemblies">The referenced assemblies.</param> /// <param name="assemblies">The list to put the information about the analyzed assemblies in.</param> private void AnalyzeReferencedAssemblies(IILAnalyzer analyzer, List <ITaskItem> refAssemblies, List <AssemblyElement> assemblies) { // Only if we have unresolved types if (analyzer.UnresolvedTypes.Count == 0) { return; } Log.LogMessageFromResources("NumberOfReferencesToResolve", analyzer.UnresolvedTypes.Count); // The previous step could introduce new assemblies, so add those to the list. List <string> assemblyFiles = new List <string>(); assemblyFiles.AddRange(analyzer.ResolveAssemblyLocations()); // Create analyzer new config CecilAnalyzerConfiguration configuration = new CecilAnalyzerConfiguration(_repositoryFileName); configuration.DoFieldAnalysis = false; configuration.DoMethodCallAnalysis = false; configuration.ExtractUnresolvedOnly = true; configuration.BinFolder = _binFolder; // Store before reset IList <string> tempUnresolvedTypes = analyzer.UnresolvedTypes; // Create a new analyzer using the object builder IEntitiesAccessor entitiesAccessor = EntitiesAccessor.Instance; analyzer = DIHelper.CreateObject <CecilILAnalyzer>(CreateContainer(entitiesAccessor, configuration)); // Set the unresolved types (because we have reset the analyzer) foreach (string type in tempUnresolvedTypes) { analyzer.UnresolvedTypes.Add(type); } // Add the assemblies to analyze. foreach (ITaskItem item in refAssemblies) { string filename = item.ToString(); if (!assemblyFiles.Contains(filename)) { assemblyFiles.Add(filename); } } // Try to resolve all the references. do { // Loop through all the referenced assemblies. foreach (string filename in assemblyFiles) { try { // See if we already have this assembly in the list AssemblyConfig asmConfig = _assembliesInConfig.Find(delegate(AssemblyConfig ac) { return(ac.FileName.Equals(filename)); }); // If a source assembly has changed, then new unresolved types can be introduced. // So we must rescan the library based on the value of assemblyChanged. // TODO: can this be optimized? if (!_assembliesDirty && asmConfig != null && File.Exists(asmConfig.TypeSpecificationFile)) { // Already in the config. Check the last modification date. if (asmConfig.Timestamp == File.GetLastWriteTime(filename).Ticks) { // Assembly has not been modified, skipping analysis Log.LogMessageFromResources("AssemblyNotModified", asmConfig.Name); _assembliesToStore.Add(asmConfig); continue; } } // Either we could not find the assembly in the config or it was changed. Log.LogMessageFromResources("AnalyzingFile", filename); Stopwatch sw = Stopwatch.StartNew(); IAnalyzerResults results = analyzer.ExtractAllTypes(filename); ShowLogItems(results.Log.LogItems); // Store the filters StoreFilters(results); // Create a new AssemblyConfig object AssemblyElement assembly = results.Assembly; if (assembly != null) { asmConfig = new AssemblyConfig(); asmConfig.FileName = filename; asmConfig.Name = assembly.Name; asmConfig.Timestamp = File.GetLastWriteTime(filename).Ticks; asmConfig.Assembly = assembly; asmConfig.IsReference = true; // Generate a unique filename asmConfig.GenerateTypeSpecificationFileName(_intermediateOutputPath); _assembliesToStore.Add(asmConfig); assemblies.Add(assembly); } sw.Stop(); Log.LogMessageFromResources("AssemblyAnalyzed", assembly.Types.Count, analyzer.UnresolvedAssemblies.Count, sw.Elapsed.TotalSeconds); } catch (ILAnalyzerException ex) { Log.LogErrorFromException(ex, true); } catch (ArgumentException ex) { Log.LogErrorFromException(ex, true); } catch (FileNotFoundException ex) { Log.LogErrorFromException(ex, true); } catch (BadImageFormatException ex) { Log.LogErrorFromException(ex, false); } } // Clear the already analyzed assemblies assemblyFiles.Clear(); // Get the unresolved assemblyFiles.AddRange(analyzer.ResolveAssemblyLocations()); }while (analyzer.UnresolvedTypes.Count > 0 && assemblyFiles.Count > 0); }