private void Render(XmlWriter reportBuilder, AssemblyInfo assemblyInfo, IEnumerable<ContextInfo> contexts) { reportBuilder.WriteStartElement("testsuite"); reportBuilder.WriteAttributeString("name", assemblyInfo.Name); // gather statistics var specsInThisAssembly = contexts.SelectMany(x => SpecificationsByContext[x]); var specsByResult = specsInThisAssembly.GroupBy(x => ResultsBySpecification[x].Status) .ToDictionary(x => x.Key, x => x.Count()); reportBuilder.WriteAttributeString("test", specsInThisAssembly.Count().ToString()); reportBuilder.WriteAttributeString("failures", specsByResult.ContainsKey(Status.Failing) ? specsByResult[Status.Failing].ToString() : "0"); reportBuilder.WriteAttributeString("skipped", ((specsByResult.ContainsKey(Status.Ignored) ? specsByResult[Status.Ignored] : 0) + (specsByResult.ContainsKey(Status.NotImplemented) ? specsByResult[Status.NotImplemented] : 0)).ToString()); foreach (var entry in contexts.GroupBy(x => x.Concern)) { RenderTestsForConcern(reportBuilder, entry.Key, entry); } reportBuilder.WriteEndElement(); }
public async Task<TestResult> RunTestAsync(AssemblyInfo assemblyInfo, CancellationToken cancellationToken) { var contentFile = _contentUtil.GetTestResultContentFile(assemblyInfo); var assemblyPath = assemblyInfo.AssemblyPath; var builder = new StringBuilder(); builder.AppendLine($"{Path.GetFileName(assemblyPath)} - {contentFile.Checksum}"); builder.AppendLine("==="); builder.AppendLine(contentFile.Content); builder.AppendLine("==="); Logger.Log(builder.ToString()); try { var cachedTestResult = await _dataStorage.TryGetCachedTestResult(contentFile.Checksum); if (cachedTestResult.HasValue) { Logger.Log($"{Path.GetFileName(assemblyPath)} - cache hit"); return Migrate(assemblyInfo, cachedTestResult.Value); } } catch (Exception ex) { Logger.Log($"Error reading cache {ex}"); } Logger.Log($"{Path.GetFileName(assemblyPath)} - running"); var testResult = await _testExecutor.RunTestAsync(assemblyInfo, cancellationToken); await CacheTestResult(contentFile, testResult).ConfigureAwait(true); return testResult; }
private string BuildTestResultContent(AssemblyInfo assemblyInfo) { var builder = new StringBuilder(); var assemblyPath = assemblyInfo.AssemblyPath; builder.AppendLine($"Assembly: {Path.GetFileName(assemblyPath)} {GetFileChecksum(assemblyPath)}"); builder.AppendLine($"Display Name: {assemblyInfo.DisplayName}"); builder.AppendLine($"Results File Name; {assemblyInfo.ResultsFileName}"); var configFilePath = $"{assemblyPath}.config"; var configFileChecksum = File.Exists(configFilePath) ? GetFileChecksum(configFilePath) : "<no config file>"; builder.AppendLine($"Config: {Path.GetFileName(configFilePath)} {configFileChecksum}"); builder.AppendLine($"Xunit: {Path.GetFileName(_options.XunitPath)} {GetFileChecksum(_options.XunitPath)}"); AppendReferences(builder, assemblyPath); builder.AppendLine("Options:"); builder.AppendLine($"\t{nameof(_options.Test64)} - {_options.Test64}"); builder.AppendLine($"\t{nameof(_options.UseHtml)} - {_options.UseHtml}"); builder.AppendLine($"\t{nameof(_options.Trait)} - {_options.Trait}"); builder.AppendLine($"\t{nameof(_options.NoTrait)} - {_options.NoTrait}"); builder.AppendLine($"Extra Options: {assemblyInfo.ExtraArguments}"); return builder.ToString(); }
public static bool IsAssemblyInGAC(string assemblyName) { var assembyInfo = new AssemblyInfo { cchBuf = 512 }; assembyInfo.currentAssemblyPath = new string('\0', assembyInfo.cchBuf); IAssemblyCache assemblyCache; var hr = CreateAssemblyCache(out assemblyCache, 0); if (hr == IntPtr.Zero) { hr = assemblyCache.QueryAssemblyInfo( 1, assemblyName, ref assembyInfo); if (hr != IntPtr.Zero) { return false; } return true; } Marshal.ThrowExceptionForHR(hr.ToInt32()); return false; }
private void AddAssemblyToList(AssemblyInfo info) { if (info != null && info.IsManagedAssembly) { listViewAssemblies.Items.Add(CreateListViewItem(info)); } }
private static ListViewItem CreateListViewItem(AssemblyInfo info) { var item = new ListViewItem(new string[] { Path.GetFileName(info.FilePath), info.DotNetVersion, (info.IsAnyCpu ? "Any CPU" : info.Is32BitOnly ? "x86" : info.Is64BitOnly ? "x64" : "UNKNOWN") + (info.Is32BitPreferred ? " (x86 preferred)" : string.Empty), info.IsSigned ? "Yes" : "No", info.FilePath }); item.Tag = info.FilePath; item.UseItemStyleForSubItems = false; // Update the color of the signed column. if (info.IsSigned) { item.SubItems[3].ForeColor = Color.Green; } else { item.SubItems[3].ForeColor = Color.Red; } return item; }
/// <summary> /// Registers the specified assembly and resolves the types in it when the AppDomain requests for it. /// </summary> /// <param name="assemblyFilePath">The path to the assemly to load in the LoadFrom context.</param> /// <remarks>This method does not load the assembly immediately, but lazily until someone requests a <see cref="Type"/> /// declared in the assembly.</remarks> public async void LoadAssemblyFrom(string assemblyFilePath) { //if (!this.handlesAssemblyResolve) //{ // AppDomain.CurrentDomain.AssemblyResolve += this.CurrentDomain_AssemblyResolve; // this.handlesAssemblyResolve = true; //} Uri assemblyUri = GetFileUri(assemblyFilePath); if (assemblyUri == null) { throw new ArgumentException(ResourceHelper.InvalidArgumentAssemblyUri, "assemblyFilePath"); } StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(new Uri(assemblyUri.AbsoluteUri)); AssemblyName assemblyName = new AssemblyName { Name = file.DisplayName }; if (this.loadedAssemblies.Any(a => assemblyName == a.AssemblyName)) { return; } var assembly = Assembly.Load(assemblyName); var assemblyInfo = new AssemblyInfo() { AssemblyName = assemblyName, AssemblyUri = assemblyUri, Assembly = assembly }; this.loadedAssemblies.Add(assemblyInfo); }
public static string GetVersion(AssemblyInfo info) { Assembly assembly = Assembly.GetExecutingAssembly(); FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location); try { switch (info) { case AssemblyInfo.Title: return fvi.ProductName; case AssemblyInfo.Version: int major = fvi.FileMajorPart; int minor = fvi.FileMinorPart; int rev = fvi.FileBuildPart; string version = major.ToString(CultureInfo.InvariantCulture) + "." + minor.ToString(CultureInfo.InvariantCulture) + "." + rev.ToString(CultureInfo.InvariantCulture); return version; case AssemblyInfo.Company: return fvi.CompanyName; } } catch (Exception) { return null; } return null; }
public void AssemblyInfoExecute() { AssemblyInfo task = new AssemblyInfo(); task.BuildEngine = new MockBuild(); task.CodeLanguage = "cs"; string outputFile = Path.Combine(testDirectory, "AssemblyInfo.cs"); task.OutputFile = outputFile; task.AssemblyTitle = "AssemblyInfoTask"; task.AssemblyDescription = "AssemblyInfo Description"; task.AssemblyConfiguration = ""; task.AssemblyCompany = "Company Name, LLC"; task.AssemblyProduct = "AssemblyInfoTask"; task.AssemblyCopyright = "Copyright (c) Company Name, LLC 2005"; task.AssemblyTrademark = ""; task.ComVisible = false; task.CLSCompliant = true; task.Guid = "d038566a-1937-478a-b5c5-b79c4afb253d"; task.AssemblyVersion = "1.2.3.4"; task.AssemblyFileVersion = "1.2.3.4"; task.AssemblyInformationalVersion = "1.2.3.4"; task.AssemblyKeyFile = @"..\MSBuild.Community.Tasks\MSBuild.Community.Tasks.snk"; Assert.IsTrue(task.Execute(), "Execute Failed"); Assert.IsTrue(File.Exists(outputFile), "File missing: " + outputFile); }
/// <summary> /// Registers the specified assembly and resolves the types in it when the AppDomain requests for it. /// </summary> /// <param name="assemblyFilePath">The path to the assemly to load in the LoadFrom context.</param> /// <remarks>This method does not load the assembly immediately, but lazily until someone requests a <see cref="Type"/> /// declared in the assembly.</remarks> public void LoadAssemblyFrom(string assemblyFilePath) { if (!this.handlesAssemblyResolve) { AppDomain.CurrentDomain.AssemblyResolve += this.CurrentDomain_AssemblyResolve; this.handlesAssemblyResolve = true; } Uri assemblyUri = GetFileUri(assemblyFilePath); if (assemblyUri == null) { throw new ArgumentException(Resources.InvalidArgumentAssemblyUri, "assemblyFilePath"); } if (!File.Exists(assemblyUri.LocalPath)) { throw new FileNotFoundException(); } AssemblyName assemblyName = AssemblyName.GetAssemblyName(assemblyUri.LocalPath); AssemblyInfo assemblyInfo = this.registeredAssemblies.FirstOrDefault(a => assemblyName == a.AssemblyName); if (assemblyInfo != null) { return; } assemblyInfo = new AssemblyInfo() { AssemblyName = assemblyName, AssemblyUri = assemblyUri }; this.registeredAssemblies.Add(assemblyInfo); }
public override void OnAssemblyStart(AssemblyInfo assembly) { _originalDirectory = Directory.GetCurrentDirectory(); if (assembly.Location != null) { Directory.SetCurrentDirectory(Path.GetDirectoryName(assembly.Location)); } }
private static TestCacheData CreateTestCacheData(AssemblyInfo assemblyInfo, string resultsFileName, CachedTestResult testResult) { return new TestCacheData() { TestResultData = CreateTestResultData(resultsFileName, testResult), TestSourceData = CreateTestSourceData(assemblyInfo) }; }
public FrmAbout() { InitializeComponent(); var ai = new AssemblyInfo(); this.Text = String.Format( "О {0}", ai.AssemblyTitle ); this.txt_vesion_null.Text = String.Format( "{0}", ai.AssemblyVersion ); this.txt_cr.Text = ai.AssemblyCopyright; }
public IAssemblyInfo LoadFrom(string assemblyName) { Assembly assembly = Assembly.LoadFrom(assemblyName); IAssemblyInfo assemblyInfo = new AssemblyInfo(); assemblyInfo.Name = assembly.FullName; assemblyInfo.Types = LoadTypes(assembly); return assemblyInfo; }
static Shell() { Input = Console.In; Output = Console.Out; Error = new ErrorConsoleWriter(Console.Error); CommandsResolver = Infrastucture.CommandsResolver.Default; HelpBuilder = HelpBuilder.Default; AssemblyInfo = new AssemblyInfo(Assembly.GetEntryAssembly() ?? Assembly.GetExecutingAssembly()); }
public long GetAssemblyTime(AssemblyInfo assemblyInfo) { if (_assemblyTimes.ContainsKey(assemblyInfo)) { return _assemblyTimes[assemblyInfo]; } return -1; }
public About() { InitializeComponent(); AssemblyInfo entryAssemblyInfo = new AssemblyInfo(System.Reflection.Assembly.GetEntryAssembly()); Titletb.Text = entryAssemblyInfo.ProductTitleAndVersion; Descriptiontb.Text = entryAssemblyInfo.Description; Copyrightb.Text = entryAssemblyInfo.Copyright; }
public override void OnAssemblyStart(AssemblyInfo assembly) { var asm = Assembly.LoadFrom(assembly.Location); var assemblyContexts = _explorer.FindAssemblyContextsIn(asm); assemblyContexts.Each(assemblyContext => { assemblyContext.OnAssemblyStart(); _executedAssemblyContexts.Add(assemblyContext); }); }
public void Initialize() { var info = new AssemblyInfo(); AboutDescriptionLabel.Text = info.Description; AboutProductLabel.Text = info.Title; var changeLog = ClassLibrary.Helper.FindResource<string>("ChangeLog.txt"); ChangeLogTextBox.Text = changeLog; var license = ClassLibrary.Helper.FindResource<string>("License.txt"); LicenseTextBox.Text = license; LicenseTabPage.Text = string.Format("{0} {1} License", Application.ProductName, new Version(Application.ProductVersion).ToString(2)); }
public void AssemblyInfo_GetCurrentAssemblyInfo_InformationsIsCorrect() { var assemblyInfo = new AssemblyInfo(Assembly.GetAssembly((typeof(AssemblyInfoTests)))); Assert.AreEqual("Alexander Krylkov", assemblyInfo.CompanyName); Assert.AreEqual("Licensed under LGPL", assemblyInfo.Copyright); Assert.AreEqual("Simplify.Core unit tests", assemblyInfo.Description); Assert.AreEqual("Simplify", assemblyInfo.ProductName); Assert.AreEqual("Simplify.Core.Tests", assemblyInfo.Title); Assert.AreEqual("1.0.0.0", assemblyInfo.Version.ToString()); }
public frmMain() { //This call is required by the Windows Form Designer. InitializeComponent(); //Add any initialization after the InitializeComponent() call // So that we only need to set the title of the application once, // we use the AssemblyInfo class (defined in the AssemblyInfo.cs file) // to read the AssemblyTitle attribute. AssemblyInfo ainfo = new AssemblyInfo(); this.Text = ainfo.Title; this.mnuAbout.Text = string.Format("&About {0} ...", ainfo.Title); }
public void It_doesnt_find_internal_types() { var assemblyInfo = new AssemblyInfo(); assemblyInfo.ReadAssembly(Compiler.GetAssembly( @"namespace MyNamespace { internal class MyInternalClass { } }")); Assert.AreEqual(0, assemblyInfo.Types.Count); }
public void It_finds_public_types() { var assemblyInfo = new AssemblyInfo(); assemblyInfo.ReadAssembly(Compiler.GetAssembly( @"namespace MyNamespace { public class MyClass { } }")); Assert.AreEqual(1, assemblyInfo.Types.Count); }
public void It_reads_the_assembly_name() { var assemblyInfo = new AssemblyInfo(); assemblyInfo.ReadAssembly(Compiler.GetAssembly("MyAssembly.dll", @"namespace MyNamespace { public class MyClass { } }")); Assert.AreEqual("MyAssembly", assemblyInfo.Name); }
public void AssemblyInfoVB() { AssemblyInfo task = new AssemblyInfo(); task.BuildEngine = new MockBuild(); task.CodeLanguage = "vb"; string outputFile = Path.Combine(testDirectory, "VersionInfo.vb"); task.OutputFile = outputFile; task.AssemblyVersion = "1.2.3.4"; task.AssemblyFileVersion = "1.2.3.4"; task.AssemblyInformationalVersion = "1.2.3.4"; Assert.IsTrue(task.Execute(), "Execute Failed"); Assert.IsTrue(File.Exists(outputFile), "File missing: " + outputFile); }
public static IAssemblyInfo ReadConfig(string configFileName, bool folderMode, string location) { var config = helper.ReadConfig(configFileName, folderMode, location); if (config == null) { config = new AssemblyInfo(); } // Convert '/' and '\\' to platform-specific path separator. ConvertConfigPaths(config); return config; }
public void It_can_exclude_specified_types() { var assemblyInfo = new AssemblyInfo(); assemblyInfo.ReadAssembly(Compiler.GetAssembly( @"namespace MyNamespace { public class MyClass1 { } public class MyClass2 { } }"), "Class2"); Assert.AreEqual("MyClass1", assemblyInfo.Types.Single().Name); }
public void It_reads_the_assembly_version() { var assemblyInfo = new AssemblyInfo(); assemblyInfo.ReadAssembly(Compiler.GetAssembly( @"[assembly: System.Reflection.AssemblyVersion(""1.2.3.4"")] namespace MyNamespace { public class MyClass { } }")); Assert.AreEqual("1.2.3.4", assemblyInfo.Version); }
internal ContentFile GetTestResultContentFile(AssemblyInfo assemblyInfo) { try { var content = BuildTestResultContent(assemblyInfo); var checksum = GetChecksum(content); return new ContentFile(checksum: checksum, content: content); } catch (Exception ex) { Logger.Log($"Error creating log file {ex.Message} {ex.StackTrace}"); return ContentFile.Empty; } }
public static string GetAssemblyPath(string name) { if (name == null) throw new ArgumentNullException(nameof(name)); var assemblyInfo = new AssemblyInfo {cchBuffer = AssemblyPathMax }; assemblyInfo.currentAssemblyPath = new string((char) 0, assemblyInfo.cchBuffer); IAssemblyCache assemblyCache; if (CreateAssemblyCache(out assemblyCache, 0) >= 0 && assemblyCache.QueryAssemblyInfo(0, name, ref assemblyInfo) < 0) return (string) null; return assemblyInfo.currentAssemblyPath; }
void AnalyzeMethodBody(AssemblyInfo assemblyInfo, MethodDefinition caller, Action <CallInfo> onCallFound, Action <ProjectIssue> onIssueFound) { if (!caller.DebugInformation.HasSequencePoints) { return; } Profiler.BeginSample("ScriptAuditor.AnalyzeMethodBody"); var callerNode = new CallTreeNode(caller); var perfCriticalContext = IsPerformanceCriticalContext(caller); foreach (var inst in caller.Body.Instructions.Where(i => m_OpCodes.Contains(i.OpCode))) { SequencePoint s = null; for (var i = inst; i != null; i = i.Previous) { s = caller.DebugInformation.GetSequencePoint(i); if (s != null) { break; } } Location location = null; if (s != null) { location = new Location(AssemblyHelper.ResolveAssetPath(assemblyInfo, s.Document.Url), s.StartLine); callerNode.location = location; } else { // sequence point not found. Assuming caller.IsHideBySig == true } if (inst.OpCode == OpCodes.Call || inst.OpCode == OpCodes.Callvirt) { onCallFound(new CallInfo { callee = (MethodReference)inst.Operand, caller = caller, location = location, perfCriticalContext = perfCriticalContext }); } foreach (var analyzer in m_InstructionAnalyzers) { if (analyzer.GetOpCodes().Contains(inst.OpCode)) { var projectIssue = analyzer.Analyze(caller, inst); if (projectIssue != null) { projectIssue.dependencies.perfCriticalContext = perfCriticalContext; projectIssue.dependencies.AddChild(callerNode); projectIssue.location = location; projectIssue.SetCustomProperties(new[] { assemblyInfo.name }); onIssueFound(projectIssue); } } } } Profiler.EndSample(); }
public void AssemblyCompleted(AssemblyInfo assembly, AssemblyResult result) { Message("testSuiteFinished name='{0}'", SuiteName(assembly)); }
public void Update(AssemblyInfo o) { ExecuteNonQuery(string.Format("UPDATE AssemblyInfo SET Name = '{0}', Description = '{1}', Project = '{2}', Configuration = '{3}', Company = '{4}', Product = '{5}', Copyright = '{6}', Trademark = '{7}', Culture = '{8}', Version = '{9}', FileVersion = '{10}', ComVisibility = '{11}' WHERE ID = '{12}'", o.Name, o.Description, o.Project, o.Configuration, o.Company, o.Product, o.Copyright, o.Trademark, o.Culture, o.Version, o.FileVersion, o.ComVisibility, o.ID.ToString())); }
public void AssemblyStart(AssemblyInfo assembly) { }
public void OnAssemblyStart(AssemblyInfo assembly) { _currentAssembly = assembly; _contextsByAssembly.Add(_currentAssembly, new List <ContextInfo>()); }
public AssemblyInfoTests() { var assembly = typeof(TestLibClass).Assembly; _info = new AssemblyInfo(assembly); }
static void Main(string[] args) { try { // Set the path of the config file. string configPath = ""; // Get the Web application configuration object. Configuration config = WebConfigurationManager.OpenWebConfiguration(configPath); // Get the section related object. CompilationSection configSection = (CompilationSection)config.GetSection("system.web/compilation"); // Display title and info. Console.WriteLine("ASP.NET Configuration Info"); Console.WriteLine(); // Display Config details. Console.WriteLine("File Path: {0}", config.FilePath); Console.WriteLine("Section Path: {0}", configSection.SectionInformation.Name); // Create a new assembly reference. AssemblyInfo myAssembly = new AssemblyInfo("MyAssembly, Version=1.0.0000.0, " + "Culture=neutral, Public KeyToken=b03f5f7f11d50a3a"); // Add an assembly to the configuration. configSection.Assemblies.Add(myAssembly); // Add a second assembly reference. AssemblyInfo myAssembly2 = new AssemblyInfo("MyAssembly2"); configSection.Assemblies.Add(myAssembly2); // Assembly Collection int i = 1; int j = 1; foreach (AssemblyInfo assemblyItem in configSection.Assemblies) { Console.WriteLine(); Console.WriteLine("Assemblies {0} Details:", i); Console.WriteLine("Type: {0}", assemblyItem.ElementInformation.Type); Console.WriteLine("Source: {0}", assemblyItem.ElementInformation.Source); Console.WriteLine("LineNumber: {0}", assemblyItem.ElementInformation.LineNumber); Console.WriteLine("Properties Count: {0}", assemblyItem.ElementInformation.Properties.Count); j = 1; foreach (PropertyInformation propertyItem in assemblyItem.ElementInformation.Properties) { Console.WriteLine("Property {0} Name: {1}", j, propertyItem.Name); Console.WriteLine("Property {0} Value: {1}", j, propertyItem.Value); j++; } i++; } // Remove an assembly. configSection.Assemblies.Remove("MyAssembly, Version=1.0.0000.0, " + "Culture=neutral, Public KeyToken=b03f5f7f11d50a3a"); // Remove an assembly. configSection.Assemblies.RemoveAt(configSection.Assemblies.Count - 1); // Update if not locked. if (!configSection.SectionInformation.IsLocked) { config.Save(); Console.WriteLine("** Configuration updated."); } else { Console.WriteLine("** Could not update, section is locked."); } } catch (Exception e) { // Unknown error. Console.WriteLine(e.ToString()); } // Display and wait. Console.ReadLine(); }
public void AssemblyStarted(AssemblyInfo assembly) { Console.WriteLine("------ Testing Assembly {0} ------", Path.GetFileName(assembly.Location)); Console.WriteLine(); }
public string GetNameForAssemblyInfo(AssemblyInfo assembly) { return(_assemblyNameMap == null ? string.Empty : _assemblyNameMap[assembly]); }
public void OnAssemblyStart(AssemblyInfo assembly) { _listener.OnAssemblyStart(assembly); }
public void AssemblyCompleted(AssemblyInfo assembly, AssemblyResult result) { log.Info(result.Summary); }
public void OnAssemblyEnd(AssemblyInfo assembly) { _listener.OnAssemblyEnd(assembly); }
public void AddOrUpdate(AssemblyInfo ainfo) { this.assemblyInfoTable.AddOrUpdate(ai => ai.AssemblyId == ainfo.AssemblyId, ainfo); }
public void IncrementUsage(AssemblyInfo sourceAssembly) { _usedInAssemblies.Add(sourceAssembly); }
public virtual void Run(GeneratorProjectInfo projectInfo) { //"lang:scharp", //@"/target C:\Work\Behemoth\Trunk\Source\Binaries\Telerik.Windows.Controls.dll", //string[] testArgs = new string[] {"/target" @"C:\Work\Behemoth\Trunk\Source\Binaries\Telerik.Windows.Controls.dll", @"/out", "c:\\dir" }; #if ENGINEONLYBUILD if (projectInfo == null) { projectInfo = new GeneratorProjectInfo(new CommandLineHelpError()); } #endif if (projectInfo == null) { CommandLineManager.WriteLineColor(ConsoleColor.Red, "args = null"); CommandLineManager.ResetColor(); return; } try { // If there is an error, there is no need to create output directory, because there will not be any project generation at all. if (projectInfo.Error == null) { try { this.CreateOutputDirectory(projectInfo); } catch (Exception ex) { if (ex is IOException || ex is UnauthorizedAccessException || ex is ArgumentException || ex is PathTooLongException || ex is DirectoryNotFoundException || ex is NotSupportedException) { projectInfo.Error = new CommandLineError(CommandLineManager.InvalidDirectoryPathError + ex.Message); } else { throw; } } } if (projectInfo.Error == null) { CommandLineManager.WriteLine(); CommandLineManager.WriteLineColor(ConsoleColor.White, description); CommandLineManager.WriteLineColor(ConsoleColor.White, new string(Enumerable.Range(0, description.Length).Select(i => '=').ToArray())); Console.WriteLine(); Console.WriteLine("Generates MS Visual Studio(r) Project from .NET assembly."); CommandLineManager.WriteLine(); if (!CLRHelper.IsValidClrFile(projectInfo.Target)) { CommandLineManager.WriteLineColor(ConsoleColor.Red, "The target assembly is not a valid CLR assembly."); return; } AssemblyDefinition assembly = Telerik.JustDecompiler.Decompiler.Utilities.GetAssembly(projectInfo.Target); ProjectGenerationSettings settings = this.GetSettings(projectInfo); if (!settings.VisualStudioSupportedProjectType) { CommandLineManager.WriteLineColor(ConsoleColor.Red, this.ReplaceRegisteredTrademarkSymbol(settings.ErrorMessage)); return; } else if (!settings.JustDecompileSupportedProjectType) { CommandLineManager.WriteLineColor(ConsoleColor.Yellow, this.ReplaceRegisteredTrademarkSymbol(settings.ErrorMessage)); CommandLineManager.WriteLine(); } else if (!projectInfo.IsDefaultFrameworkVersion) { AssemblyInfo assemblyInfo = NoCacheAssemblyInfoService.Instance.GetAssemblyInfo(assembly, new ConsoleFrameworkResolver(projectInfo.FrameworkVersion)); if (assemblyInfo.ModulesFrameworkVersions[assembly.MainModule] != projectInfo.FrameworkVersion) { CommandLineManager.WriteLineColor(ConsoleColor.Yellow, "JustDecompile managed to determine the target assembly framework. The fallback target framework version command line option is ignored."); CommandLineManager.WriteLine(); } } CommandLineManager.WriteLineColor(ConsoleColor.White, "Project Creation:"); CommandLineManager.WriteLineColor(ConsoleColor.White, "============================"); TimeSpan projectGenerationTime = RunInternal(assembly, projectInfo, settings); CommandLineManager.WriteLine(); CommandLineManager.WriteLineColor(ConsoleColor.White, "============================"); CommandLineManager.WriteLineColor(ConsoleColor.White, string.Format("Finished in {0:0.0} seconds.", projectGenerationTime.TotalSeconds)); count = 0; } else { projectInfo.Error.PrintError(); } } catch (Exception ex) { CommandLineManager.WriteLine(); CommandLineManager.WriteLineColor(ConsoleColor.Red, ex.Message); OnExceptionThrown(ex); } finally { CommandLineManager.WriteLine(); CommandLineManager.ResetColor(); } }
internal static Assembly ResolveAssembly(object sender, ResolveEventArgs e) { AssemblyInfo info = new AssemblyInfo(e.Name); string assemblyFullName = info.GetAssemblyFullName(false); string str2 = Convert.ToBase64String(Encoding.UTF8.GetBytes(assemblyFullName)); string[] strArray = "ezJiMjQwNDRmLTY0NDgtNDczMi1hMGQ4LTlhNGIzNzg0MWY0N30sIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49M2U1NjM1MDY5M2Y3MzU1ZQ==,[z]{5afba4e7-4cbd-48f4-ae87-5cb4a100aac0},ezJiMjQwNDRmLTY0NDgtNDczMi1hMGQ4LTlhNGIzNzg0MWY0N30=,[z]{5afba4e7-4cbd-48f4-ae87-5cb4a100aac0},SHRtbEFnaWxpdHlQYWNrLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWJkMzE5YjE5ZWFmM2I0M2E=,[z]{22a11d39-8946-4a47-958b-a3b1fb426f2d},SHRtbEFnaWxpdHlQYWNr,[z]{22a11d39-8946-4a47-958b-a3b1fb426f2d}".Split(new char[] { ',' }); string key = string.Empty; bool flag = false; bool flag2 = false; for (int i = 0; i < (strArray.Length - 1); i += 2) { if (strArray[i] == str2) { key = strArray[i + 1]; break; } } if ((key.Length == 0) && (info.PublicKeyToken.Length == 0)) { str2 = Convert.ToBase64String(Encoding.UTF8.GetBytes(info.Name)); for (int j = 0; j < (strArray.Length - 1); j += 2) { if (strArray[j] == str2) { key = strArray[j + 1]; break; } } } if (key.Length > 0) { if (key[0] == '[') { int index = key.IndexOf(']'); string str4 = key.Substring(1, index - 1); flag = str4.IndexOf('z') >= 0; flag2 = str4.IndexOf('t') >= 0; key = key.Substring(index + 1); } lock (hashtable) { if (hashtable.ContainsKey(key)) { return(hashtable[key]); } Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(key); if (manifestResourceStream != null) { int length = (int)manifestResourceStream.Length; byte[] buffer = new byte[length]; manifestResourceStream.Read(buffer, 0, length); if (flag) { buffer = SimpleZip.Unzip(buffer); } Assembly assembly = null; if (!flag2) { try { assembly = Assembly.Load(buffer); } catch (FileLoadException) { flag2 = true; } catch (BadImageFormatException) { flag2 = true; } } if (flag2) { try { string path = string.Format(@"{0}{1}\", Path.GetTempPath(), key); Directory.CreateDirectory(path); string str6 = path + info.Name + ".dll"; if (!File.Exists(str6)) { FileStream stream2 = File.OpenWrite(str6); stream2.Write(buffer, 0, buffer.Length); stream2.Close(); MoveFileEx(str6, null, 4); MoveFileEx(path, null, 4); } assembly = Assembly.LoadFile(str6); } catch { } } hashtable[key] = assembly; return(assembly); } } } return(null); }
public void OnAssemblyEnd(AssemblyInfo assembly) { _currentAssembly.CapturedOutput = assembly.CapturedOutput; }
public async IAsyncEnumerable <SourceFile> Load(SessionId sessionId, string[] loaded_files, [EnumeratorCancellation] CancellationToken token) { var asm_files = new List <string>(); var pdb_files = new List <string>(); foreach (string file_name in loaded_files) { if (file_name.EndsWith(".pdb", StringComparison.OrdinalIgnoreCase)) { pdb_files.Add(file_name); } else { asm_files.Add(file_name); } } List <DebugItem> steps = new List <DebugItem>(); foreach (string url in asm_files) { try { string candidate_pdb = Path.ChangeExtension(url, "pdb"); string pdb = pdb_files.FirstOrDefault(n => n == candidate_pdb); steps.Add( new DebugItem { Url = url, Data = Task.WhenAll(client.GetByteArrayAsync(url, token), pdb != null ? client.GetByteArrayAsync(pdb, token) : Task.FromResult <byte[]>(null)) }); } catch (Exception e) { logger.LogDebug($"Failed to read {url} ({e.Message})"); } } foreach (DebugItem step in steps) { AssemblyInfo assembly = null; try { byte[][] bytes = await step.Data.ConfigureAwait(false); assembly = new AssemblyInfo(step.Url, bytes[0], bytes[1]); } catch (Exception e) { logger.LogDebug($"Failed to load {step.Url} ({e.Message})"); } if (assembly == null) { continue; } if (GetAssemblyByUnqualifiedName(assembly.AssemblyNameUnqualified) != null) { logger.LogDebug($"Skipping loading {assembly.Name} into the debug store, as it already exists"); continue; } assemblies.Add(assembly); foreach (SourceFile source in assembly.Sources) { yield return(source); } } }
/// Initializes a new instance of the class. public App() { Properties["Authors"] = "Cédric Belin <*****@*****.**>"; Properties["License"] = OpenSourceLicenses.GnuGeneralPublicLicenseV3; Properties["Product"] = new AssemblyInfo(GetType().Assembly).Product; }
private static StartupHandlerInfo[] GetSubscribedTypes( string filePath, List <AssemblyInfo> cachedTypesInfo, ref bool cacheHasBeenUpdated) { string assemblyName = Path.GetFileNameWithoutExtension(filePath); foreach (string assemblyToIgnore in AssembliesToIgnore) { if (assemblyName == assemblyToIgnore || assemblyName.StartsWith(assemblyToIgnore + ",") || (assemblyToIgnore.EndsWith(".") && assemblyName.StartsWith(assemblyToIgnore))) { return(null); } } DateTime modificationDate = C1File.GetLastWriteTime(filePath); var cachedInfo = cachedTypesInfo.FirstOrDefault(asm => asm.AssemblyName == assemblyName); if (cachedInfo != null) { if (cachedInfo.LastModified == modificationDate) { string[] subscribedTypesNames = cachedInfo.SubscribedTypes; if (subscribedTypesNames.Length == 0) { return(new StartupHandlerInfo[0]); } var asm = Assembly.LoadFrom(filePath); return((from typeName in subscribedTypesNames let type = asm.GetType(typeName) where type != null let attribute = type.GetCustomAttributes(false) .OfType <ApplicationStartupAttribute>() .FirstOrDefault() where attribute != null select new StartupHandlerInfo(type, attribute)).ToArray()); } // Removing cache entry if it is obsolete cachedTypesInfo.Remove(cachedInfo); } Assembly assembly; try { assembly = Assembly.LoadFrom(filePath); } catch (ReflectionTypeLoadException ex) { Log.LogWarning(LogTitle, $"Failed to load assembly '{filePath}'"); if (ex.LoaderExceptions != null && ex.LoaderExceptions.Length > 0) { Log.LogError(LogTitle, ex.LoaderExceptions[0]); } return(null); } if (!AssemblyFacade.AssemblyPotentiallyUsesType(assembly, typeof(ApplicationStartupAttribute))) { return(null); } Type[] types; if (!TryGetTypes(assembly, out types)) { return(new StartupHandlerInfo[0]); } var result = GetSubscribedTypes(types); var newCacheEntry = new AssemblyInfo { AssemblyName = assembly.GetName().Name, LastModified = modificationDate, SubscribedTypes = result.Select(sh => sh.Type.FullName).ToArray() }; cachedTypesInfo.Add(newCacheEntry); cacheHasBeenUpdated = true; return(result); }
public static MemoryStream Compile(AssemblyInfo assemblyInfo, IEnumerable <SyntaxTree> trees, IEnumerable <MetadataReference> references, ILogger logger = null) { return(Compile(assemblyInfo.Title, assemblyInfo, trees, references, logger)); }
static string SuiteName(AssemblyInfo assembly) { return(Path.GetFileName(assembly.Location)); }
private static SyntaxTree GetAssemblyInfo(AssemblyInfo info) { return(SyntaxFactory.CompilationUnit() .WithUsings( SyntaxFactory.List( new[] { SyntaxFactory.UsingDirective( SyntaxFactory.QualifiedName( SyntaxFactory.IdentifierName("System"), SyntaxFactory.IdentifierName("Reflection"))), SyntaxFactory.UsingDirective( SyntaxFactory.QualifiedName( SyntaxFactory.QualifiedName( SyntaxFactory.IdentifierName("System"), SyntaxFactory.IdentifierName("Runtime")), SyntaxFactory.IdentifierName("InteropServices"))), SyntaxFactory.UsingDirective( SyntaxFactory.QualifiedName( SyntaxFactory.QualifiedName( SyntaxFactory.IdentifierName("System"), SyntaxFactory.IdentifierName("Runtime")), SyntaxFactory.IdentifierName("Versioning"))) })) .WithAttributeLists( SyntaxFactory.List( new[] { SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("TargetFramework")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SeparatedList <AttributeArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(".NETFramework,Version=v4.5"))), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(".NET Framework 4.5"))) .WithNameEquals( SyntaxFactory.NameEquals( SyntaxFactory.IdentifierName("FrameworkDisplayName"))) }))))) .WithTarget( SyntaxFactory.AttributeTargetSpecifier( SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))), SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("AssemblyTitle")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(info.Title)))))))) .WithTarget( SyntaxFactory.AttributeTargetSpecifier( SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))), SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("AssemblyProduct")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(info.Product)))))))) .WithTarget( SyntaxFactory.AttributeTargetSpecifier( SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))), SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("AssemblyCopyright")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(info.Copyright)))))))) .WithTarget( SyntaxFactory.AttributeTargetSpecifier( SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))), SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("ComVisible")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression(info.ComVisible ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression))))))) .WithTarget( SyntaxFactory.AttributeTargetSpecifier( SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))), SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("Guid")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(info.Guid)))))))) .WithTarget( SyntaxFactory.AttributeTargetSpecifier( SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))), SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("AssemblyVersion")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(info.Version)))))))) .WithTarget( SyntaxFactory.AttributeTargetSpecifier( SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))), SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("AssemblyFileVersion")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(info.FileVersion)))))))) .WithTarget( SyntaxFactory.AttributeTargetSpecifier( SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))) })) .NormalizeWhitespace() .SyntaxTree); }
public void AssemblyCompleted(AssemblyInfo assembly, AssemblyResult result) { Console.WriteLine(result.Summary); Console.WriteLine(); }
public void OnAssemblyEnd(AssemblyInfo assembly) { _output.AssemblyEnd(assembly); }
public void OnAssemblyStart(AssemblyInfo assembly) { _output.AssemblyStart(assembly); }
public void Create(AssemblyInfo o) { ExecuteNonQuery(string.Format("INSERT INTO AssemblyInfo(ID, Name, Description, Project, Configuration, Company, Product, Copyright, Trademark, Culture, Version, FileVersion, ComVisibility) VALUES('{0}', '{1}', '{2}', '{3}', '{4}', '{5}', '{6}', '{7}', '{8}', '{9}', '{10}', '{11}', '{12}')", o.ID.ToString(), o.Name, o.Description, o.Project, o.Configuration, o.Company, o.Product, o.Copyright, o.Trademark, o.Culture, o.Version, o.FileVersion, o.ComVisibility)); }
public void AssemblyStarted(AssemblyInfo assembly) { Message("testSuiteStarted name='{0}'", SuiteName(assembly)); }
public void AssemblyEnd(AssemblyInfo assembly) { }
protected override void ProcessRecord() { base.ProcessRecord(); WriteVerbose("Plugin Registration intiated"); if (UseSplitAssembly) { if (!File.Exists(ProjectFilePath)) { throw new Exception("Project File Path is required if you want to split assembly."); } if (RegistrationType == RegistrationTypeEnum.Delsert) { throw new Exception("Registration type 'Remove Plugin Types and Steps which are not in mapping and Upsert' will not work when 'Split Assembly' is enabled."); } if (!File.Exists(MappingFile)) { throw new Exception("Mapping Json Path is required if you want to split assembly."); } } var assemblyInfo = AssemblyInfo.GetAssemblyInfo(AssemblyPath); WriteVerbose($"Assembly Name: {assemblyInfo.AssemblyName}"); WriteVerbose($"Assembly Version: {assemblyInfo.Version}"); using (var context = new CIContext(OrganizationService)) { var pluginRegistrationHelper = new PluginRegistrationHelper(OrganizationService, context, WriteVerbose, WriteWarning); WriteVerbose("PluginRegistrationHelper intiated"); Assembly pluginAssembly = null; Guid pluginAssemblyId = Guid.Empty; if (File.Exists(MappingFile)) { pluginAssembly = pluginRegistrationHelper.ReadMappingFile(MappingFile); pluginAssemblyId = pluginAssembly.Id ?? Guid.Empty; } else { pluginAssemblyId = pluginRegistrationHelper.UpsertPluginAssembly(pluginAssembly, assemblyInfo, SolutionName, RegistrationType); WriteVerbose($"UpsertPluginAssembly {pluginAssemblyId} completed"); WriteVerbose("Plugin Registration completed"); return; } if (pluginAssembly == null) { WriteVerbose("Plugin Registration completed"); return; } if (pluginAssembly.PluginTypes == null) { WriteVerbose("No mapping found for types."); WriteVerbose("Plugin Registration completed"); return; } if (RegistrationType == RegistrationTypeEnum.Delsert) { WriteVerbose($"RemoveComponentsNotInMapping {assemblyInfo.AssemblyName} started"); pluginRegistrationHelper.RemoveComponentsNotInMapping(pluginAssembly); WriteVerbose($"RemoveComponentsNotInMapping {assemblyInfo.AssemblyName} completed"); RegistrationType = RegistrationTypeEnum.Upsert; } if (UseSplitAssembly) { foreach (var type in pluginAssembly.PluginTypes) { UploadSplitAssembly(assemblyInfo, pluginRegistrationHelper, type); } } else { WriteVerbose($"UpsertPluginAssembly {pluginAssemblyId} started"); pluginAssemblyId = pluginRegistrationHelper.UpsertPluginAssembly(pluginAssembly, assemblyInfo, SolutionName, RegistrationType); WriteVerbose($"UpsertPluginAssembly {pluginAssemblyId} completed"); foreach (var type in pluginAssembly.PluginTypes) { pluginRegistrationHelper.UpsertPluginTypeAndSteps(pluginAssemblyId, type, SolutionName, RegistrationType); } } } WriteVerbose("Plugin Registration completed"); }