private async void OpenFile()
{
var assemblyFileType = new FileType(".NET Assembly (*.dll, *.exe)", ".dll;*.exe");
var allFileType = new FileType("All files (*.*)", ".*");
var result = fileDialogService.ShowOpenFileDialog(ShellViewModel.View, new[] { assemblyFileType, allFileType });
if (!result.IsValid)
{
return;
}
try
{
using (ShellViewModel.SetApplicationBusy())
{
var assemblyApi = await Task.Run(() => AssemblyReader.Read(result.FileName));
AddAndSelectAssemblyApi(result.FileName, assemblyApi.version, assemblyApi.api);
}
}
catch (Exception e)
{
messageService.ShowError(ShellViewModel.View, "Could not read the file. Error: " + e);
}
}
public void Initialize()
{
AssemblyReader asmInfoProcessor = new AssemblyReader();
result = asmInfoProcessor.Read(dllPath);
testClassType = typeof(TestClass);
}
private string GetSdkToTest(string sdkDir)
{
// The TFM we're testing
var testTfm = AssemblyReader.GetTargetFramework(typeof(MsbuildIntegrationTestFixture).Assembly.Location);
var selectedVersion =
Directory.EnumerateDirectories(sdkDir) // get all directories in sdk folder
.Where(path =>
{ // SDK is for TFM to test
if (string.Equals(Path.GetFileName(path), "NuGetFallbackFolder", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
var dotnetPath = Path.Combine(path, "dotnet.dll");
var sdkTfm = AssemblyReader.GetTargetFramework(dotnetPath);
return(testTfm == sdkTfm);
})
.Select(Path.GetFileName) // just the folder name (version string)
.OrderByDescending(path => NuGetVersion.Parse(Path.GetFileName(path))) // in case there are multiple matching SDKs, selected the highest version
.FirstOrDefault();
if (selectedVersion == null)
{
var message = $@"Could not find suitable SDK to test in {sdkDir}
TFM being tested: {testTfm.DotNetFrameworkName}
SDKs found: {string.Join(", ", Directory.EnumerateDirectories(sdkDir).Select(Path.GetFileName).Where(d => !string.Equals(d, "NuGetFallbackFolder", StringComparison.OrdinalIgnoreCase)))}";
throw new Exception(message);
}
return(selectedVersion);
}
public void Initialize()
{
const string path = @"..\..\TestDLL\Faker.dll";
reader = new AssemblyReader();
namespaces = reader.LoadAssemblyTypes(path);
}
/* ----------------------------------------------------------------- */
///
/// Save
///
/// <summary>
/// 設定を保存します。
/// </summary>
///
/* ----------------------------------------------------------------- */
public void Save(string path)
{
if (string.IsNullOrEmpty(path))
{
return;
}
var directory = IoEx.Path.GetDirectoryName(path);
if (string.IsNullOrEmpty(directory))
{
return;
}
if (!IoEx.Directory.Exists(directory))
{
IoEx.Directory.CreateDirectory(directory);
}
FileType.Serialize(path, User);
var asm = new AssemblyReader(Assembly);
var name = "cubenote-checker";
var exe = IoEx.Path.Combine(asm.DirectoryName, "CubeChecker.exe");
var args = "CubeNote";
new Cube.FileSystem.Startup(name)
{
Command = $"\"{exe}\" {args}",
Enabled = User.ShowUpdate && IoEx.File.Exists(exe),
}.Save();
}
public int UpdateSolution_Done(int fSucceeded, int fModified, int fCancelCommand)
{
if (Common.Instance.GeneralOptions.UpdateListingOnlyIfVisible && !MsilerToolWindow.IsVisible)
{
return(VSConstants.S_OK);
}
if (fSucceeded != 1)
{
return(VSConstants.S_OK);
}
string assemblyFile = DteHelpers.GetOutputAssemblyFileName();
try {
var assemblyWriteTime = new FileInfo(assemblyFile).LastWriteTime;
// if assembly was not changed
if (this._previousAssemblyWriteTime == assemblyWriteTime)
{
return(VSConstants.S_OK);
}
var options = new AssemblyParserOptions {
ProcessPDB = Common.Instance.ListingGenerationOptions.ProcessPdbFiles
};
this._assemblyReader = new AssemblyReader(assemblyFile, options);
this._previousAssemblyWriteTime = assemblyWriteTime;
this.OnMethodListChanged(this._assemblyReader.Methods);
} catch (Exception) {
this.OnMethodListChanged(new List <AssemblyMethod>());
}
return(VSConstants.S_OK);
}
private void CopyRestoreArtifacts(string artifactsDirectory, string pathToSdkInCli, string configuration, string toolsetVersion)
{
const string restoreProjectName = "NuGet.Build.Tasks";
const string restoreTargetsName = "NuGet.targets";
var sdkDependencies = new List <string> {
restoreProjectName, "NuGet.Versioning", "NuGet.Protocol", "NuGet.ProjectModel", "NuGet.Packaging", "NuGet.LibraryModel", "NuGet.Frameworks", "NuGet.DependencyResolver.Core", "NuGet.Configuration", "NuGet.Common", "NuGet.Commands", "NuGet.CommandLine.XPlat", "NuGet.Credentials"
};
var sdkTfm = AssemblyReader.GetTargetFramework(Path.Combine(pathToSdkInCli, "dotnet.dll"));
// Copy rest of the NuGet assemblies.
foreach (var projectName in sdkDependencies)
{
var projectArtifactsBinFolder = Path.Combine(artifactsDirectory, projectName, toolsetVersion, "bin", configuration);
var tfmToCopy = GetTfmToCopy(sdkTfm, projectArtifactsBinFolder);
var frameworkArtifactsFolder = new DirectoryInfo(Path.Combine(projectArtifactsBinFolder, tfmToCopy));
var fileName = projectName + ".dll";
File.Copy(
sourceFileName: Path.Combine(frameworkArtifactsFolder.FullName, fileName),
destFileName: Path.Combine(pathToSdkInCli, fileName),
overwrite: true);
// Copy the restore targets.
if (projectName.Equals(restoreProjectName))
{
File.Copy(
sourceFileName: Path.Combine(frameworkArtifactsFolder.FullName, restoreTargetsName),
destFileName: Path.Combine(pathToSdkInCli, restoreTargetsName),
overwrite: true);
}
}
}
public void AssemblyReader_Should_EnableReflectionOnlyLoad()
{
var assemblyUtilMock = new Mock <IAssemblyUtils>();
var sut = new AssemblyReader(assemblyUtilMock.Object);
assemblyUtilMock.Verify(x => x.EnableReflectionOnlyLoad(It.IsAny <Func <object, ResolveEventArgs, Assembly> >()), Times.Once);
}
public static bool CompareAssemblies(string a, string b, bool ignore_cache = false, bool compare_guids = false)
{
if (Driver.Force && !ignore_cache)
{
Driver.Log(6, "Assemblies {0} and {1} are considered different because -f was passed to " + NAME + ".", a, b);
return(false);
}
if (!File.Exists(b))
{
Driver.Log(6, "Assemblies {0} and {1} are considered different because the latter doesn't exist.", a, b);
return(false);
}
using (var astream = new AssemblyReader(a)
{
CompareGUIDs = compare_guids
}) {
using (var bstream = new AssemblyReader(b)
{
CompareGUIDs = compare_guids
}) {
bool rv;
Driver.Log(6, "Comparing assemblies {0} and {1}...", a, b);
rv = CompareStreams(astream, bstream, ignore_cache);
Driver.Log(6, " > {0}", rv ? "Identical" : "Different");
return(rv);
}
}
}
public void Should_get_framework_version_from_assembly()
{
var assembly = new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath;
var locator = new AssemblyReader();
Assert.That(locator.GetTargetFramework(assembly), Is.EqualTo(new Version(2, 0)));
}
public void DisposeReader()
{
if ( rdr != null )
rdr.Dispose();
rdr = null;
}
/* ----------------------------------------------------------------- */
///
/// FileResource
///
/// <summary>
/// オブジェクトを初期化します。
/// </summary>
///
/* ----------------------------------------------------------------- */
protected FileResource()
{
var reader = new AssemblyReader(Assembly.GetExecutingAssembly());
Root = IoEx.Path.GetDirectoryName(reader.Location);
_folder = GetType().FullName.Replace($"{reader.Product}.", "");
Initialize();
}
/* ----------------------------------------------------------------- */
///
/// Initialize
///
/// <summary>
/// オブジェクトを初期化します。
/// </summary>
///
/* ----------------------------------------------------------------- */
private void Initialize(AssemblyReader reader, SettingsType type)
{
var root = type == SettingsType.Registry ?
"Software" :
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
var path = System.IO.Path.Combine(root, $@"{reader.Company}\{reader.Product}");
Initialize(reader, type, path);
}
/* ----------------------------------------------------------------- */
///
/// GetUserAgent
///
/// <summary>
/// User-Agent を表す文字列を取得します。
/// </summary>
///
/* ----------------------------------------------------------------- */
private string GetUserAgent()
{
var asm = new AssemblyReader(Assembly.GetExecutingAssembly());
var app = $"{asm.Product}/{asm.Version}";
var win = Environment.OSVersion.VersionString;
var net = $".NET {Environment.Version}";
return($"{app} ({win}; {net})");
}
Accession37, IDictionary <string, IChromosome> Accession38) GetSequenceDictionaries(string referencePath,
string assemblyInfo37Path, string assemblyInfo38Path)
{
var(_, refNameToChromosome, _) = SequenceHelper.GetDictionaries(referencePath);
var accession37Dict = AssemblyReader.GetAccessionToChromosome(GZipUtilities.GetAppropriateStreamReader(assemblyInfo37Path), refNameToChromosome);
var accession38Dict = AssemblyReader.GetAccessionToChromosome(GZipUtilities.GetAppropriateStreamReader(assemblyInfo38Path), refNameToChromosome);
return(refNameToChromosome, accession37Dict, accession38Dict);
}
public void DisposeReader()
{
if (rdr != null)
{
rdr.Dispose();
}
rdr = null;
}
static void Main()
{
AssemblyReader assembly = new AssemblyReader("C:/Users/gnygl/Desktop/projects/reflectionTrainings/CSharpToJava/c#toJava/ReflectionTraining2/bin/Debug/Paximum.Content.Messages.dll");
TypeHandler typeHandler = new TypeHandler(assembly.GetAssembly());
var elements = typeHandler.TypeSender();
FileWriter fileWriter = new FileWriter("C:/Users/gnygl/Desktop/gnygldnm/", elements, "gnygldnm");
fileWriter.Write();
}
/* ----------------------------------------------------------------- */
///
/// InitLog
///
/// <summary>
/// ログを出力します。
/// </summary>
///
/* ----------------------------------------------------------------- */
static void InitLog()
{
var reader = new AssemblyReader(Assembly.GetExecutingAssembly());
var edition = (IntPtr.Size == 4) ? "x86" : "x64";
var type = typeof(Program);
Logger.Info(type, $"{reader.Product} {reader.Version} ({edition})");
Logger.Info(type, $"{Environment.OSVersion}");
Logger.Info(type, $"{Environment.Version}");
}
/* ----------------------------------------------------------------- */
///
/// Info
///
/// <summary>
/// システム情報をログに出力します。
/// </summary>
///
/// <param name="type">対象となるオブジェクトの型情報</param>
/// <param name="assembly">アセンブリ情報</param>
///
/* ----------------------------------------------------------------- */
public static void Info(Type type, Assembly assembly)
{
var asm = new AssemblyReader(assembly);
var sv = new SoftwareVersion(assembly);
Info(type, $"{asm.Product} {sv.ToString(true)}");
Info(type, $"{Environment.OSVersion}");
Info(type, $"Microsoft .NET Framework {Environment.Version}");
Info(type, $"{Environment.UserName}@{Environment.MachineName}");
}
/* ----------------------------------------------------------------- */
///
/// CreateSubKey
///
/// <summary>
/// レジストリのサブキーを生成します。
/// </summary>
///
/* ----------------------------------------------------------------- */
private RegistryKey CreateSubKey()
{
if (Assembly == null)
{
return(null);
}
var reader = new AssemblyReader(Assembly);
var name = $@"Software\{reader.Company}\{reader.Product}";
return(Registry.CurrentUser.CreateSubKey(name));
}
public void ReadAssembly()
{
var asm = typeof(object).GetTypeInfo().Assembly;
using (var stream = File.OpenRead(asm.Location))
using (var reader = new AssemblyReader(stream))
{
var result = reader.ReadAssembly();
//reader.BaseStream.Should().Be(expected, Output);
}
}
private static AssemblyDefinition CreateAssemblyDefinition(AssemblyReference assemblyRef)
{
var assemblyName = new AssemblyName(assemblyRef.ToString());
var assembly = Assembly.Load(assemblyName);
using (var stream = File.OpenRead(assembly.Location))
using (var reader = new AssemblyReader(stream))
{
return(reader.ReadAssembly());
}
}
private void CopyPackSdkArtifacts(string artifactsDirectory, string pathToSdkInCli, string configuration, string toolsetVersion)
{
var pathToPackSdk = Path.Combine(pathToSdkInCli, "Sdks", "NuGet.Build.Tasks.Pack");
var sdkTfm = AssemblyReader.GetTargetFramework(Path.Combine(pathToSdkInCli, "dotnet.dll"));
const string packProjectName = "NuGet.Build.Tasks.Pack";
const string packTargetsName = "NuGet.Build.Tasks.Pack.targets";
// Copy the pack SDK.
var packProjectBinDirectory = Path.Combine(artifactsDirectory, packProjectName, toolsetVersion, "bin", configuration);
var tfmToCopy = GetTfmToCopy(sdkTfm, packProjectBinDirectory);
var packProjectCoreArtifactsDirectory = new DirectoryInfo(Path.Combine(packProjectBinDirectory, tfmToCopy));
// We are only copying the CoreCLR assets, since, we're testing only them under Core MSBuild.
var targetRuntimeType = "CoreCLR";
var packAssemblyDestinationDirectory = Path.Combine(pathToPackSdk, targetRuntimeType);
// Be smart here so we don't have to call ILMerge in the VS build. It takes ~15s total.
// In VisualStudio, simply use the non il merged version.
var ilMergedPackDirectoryPath = Path.Combine(packProjectCoreArtifactsDirectory.FullName, "ilmerge");
if (Directory.Exists(ilMergedPackDirectoryPath))
{
var packFileName = packProjectName + ".dll";
// Only use the il merged assembly if it's newer than the build.
DateTime packAssemblyCreationDate = File.GetCreationTimeUtc(Path.Combine(packProjectCoreArtifactsDirectory.FullName, packFileName));
DateTime ilMergedPackAssemblyCreationDate = File.GetCreationTimeUtc(Path.Combine(ilMergedPackDirectoryPath, packFileName));
if (ilMergedPackAssemblyCreationDate > packAssemblyCreationDate)
{
FileUtility.Replace(
sourceFileName: Path.Combine(packProjectCoreArtifactsDirectory.FullName, "ilmerge", packFileName),
destFileName: Path.Combine(packAssemblyDestinationDirectory, packFileName));
}
}
else
{
foreach (var assembly in packProjectCoreArtifactsDirectory.EnumerateFiles("*.dll"))
{
File.Copy(
sourceFileName: assembly.FullName,
destFileName: Path.Combine(packAssemblyDestinationDirectory, assembly.Name),
overwrite: true);
}
}
// Copy the pack targets
var packTargetsSource = Path.Combine(packProjectCoreArtifactsDirectory.FullName, packTargetsName);
var targetsDestination = Path.Combine(pathToPackSdk, "build", packTargetsName);
var targetsDestinationCrossTargeting = Path.Combine(pathToPackSdk, "buildCrossTargeting", packTargetsName);
File.Copy(packTargetsSource, targetsDestination, overwrite: true);
File.Copy(packTargetsSource, targetsDestinationCrossTargeting, overwrite: true);
}
public Assembly LoadAssembly(RawModule module)
{
string refname = module.GetAssemblyName().FullName;
Assembly asm = GetLoadedAssembly(refname);
if (asm == null)
{
AssemblyReader asm1 = module.ToAssembly();
assemblies.Add(asm1);
asm = asm1;
}
return(asm);
}
private static ExitCodes ProgramExecution()
{
var genomeAssembly = GenomeAssemblyHelper.Convert(_genomeAssembly);
Console.Write("- loading previous reference names... ");
List <IChromosome> oldChromosomes = ReferenceNamesReader.GetReferenceNames(FileUtilities.GetReadStream(_referenceNamesPath));
Console.WriteLine("finished.");
IDictionary <string, IChromosome> oldRefNameToChromosome = ReferenceDictionaryUtils.GetRefNameToChromosome(oldChromosomes);
Console.Write("- reading the genome assembly report... ");
List <IChromosome> chromosomes = AssemblyReader.GetChromosomes(FileUtilities.GetReadStream(_genomeAssemblyReportPath), oldRefNameToChromosome, oldChromosomes.Count);
int numRefSeqs = chromosomes.Count;
Console.WriteLine($"{numRefSeqs} references found.");
Console.Write("- checking reference index contiguity... ");
CheckReferenceIndexContiguity(chromosomes, oldChromosomes);
Console.WriteLine("contiguous.");
IDictionary <string, IChromosome> refNameToChromosome = ReferenceDictionaryUtils.GetRefNameToChromosome(chromosomes);
Console.Write("- reading cytogenetic bands... ");
List <Band>[] cytogeneticBandsByRef = CytogeneticBandsReader.GetCytogeneticBands(FileUtilities.GetReadStream(_cytogeneticBandPath),
numRefSeqs, refNameToChromosome);
Console.WriteLine("finished.");
Console.WriteLine("- reading FASTA files:");
List <FastaSequence> fastaSequences = GetFastaSequences(_fastaPrefix, refNameToChromosome);
long genomeLength = GetGenomeLength(fastaSequences);
Console.WriteLine($"- genome length: {genomeLength:N0}");
Console.Write("- check if chrY has PAR masking... ");
CheckChrYPadding(fastaSequences);
Console.WriteLine("unmasked.");
Console.Write("- applying 2-bit compression... ");
List <Creation.ReferenceSequence> referenceSequences = CreateReferenceSequences(fastaSequences, cytogeneticBandsByRef);
Console.WriteLine("finished.");
Console.Write("- creating reference sequence file... ");
CreateReferenceSequenceFile(genomeAssembly, _patchLevel, chromosomes, referenceSequences);
long fileSize = new FileInfo(_outputCompressedPath).Length;
Console.WriteLine($"{fileSize:N0} bytes");
return(ExitCodes.Success);
}
protected virtual Type GetEntityType(string entityName)
{
Type result = AssemblyReader.FindType(
GOCWindows.Instance.LinqToClassesAssembly,
GOCWindows.Instance.LinqToSQLClassesNamespace,
entityName,
false);
if (result == null)
{
throw new NullReferenceException(string.Format("Could not find entity with name {0}.", entityName));
}
return(result);
}
public void LoadAssembly_Should_CreateAssemblyInfo_WhenCalledWithAssembly()
{
// Arrange
var assemblyUtilMock = new Mock <IAssemblyUtils>();
var thisAssembly = CreateAssemblyMock("L", "A").Object;
var sut = new AssemblyReader(assemblyUtilMock.Object);
// Act
var actualAssembly = sut.LoadAssembly(thisAssembly);
// Assert
Assert.AreSame(thisAssembly, actualAssembly.Assembly);
}
/* ----------------------------------------------------------------- */
///
/// UpdateText
///
/// <summary>
/// フォームのタイトルを "message - ProductName" と言う表記で
/// 更新します。
/// </summary>
///
/// <param name="form">フォーム</param>
/// <param name="message">タイトルに表示するメッセージ</param>
/// <param name="assembly">アセンブリ情報</param>
///
/* ----------------------------------------------------------------- */
public static void UpdateText(this System.Windows.Forms.Form form, string message, Assembly assembly)
{
var asm = new AssemblyReader(assembly);
var ss = new System.Text.StringBuilder();
ss.Append(message);
if (!string.IsNullOrEmpty(message) && !string.IsNullOrEmpty(asm.Product))
{
ss.Append(" - ");
}
ss.Append(asm.Product);
form.Text = ss.ToString();
}
/* ----------------------------------------------------------------- */
///
/// Initialize
///
/// <summary>
/// オブジェクトを初期化します。
/// </summary>
///
/* ----------------------------------------------------------------- */
private void Initialize(AssemblyReader reader, SettingsType type, string path)
{
Type = type;
Path = path;
Version = new SoftwareVersion(reader.Assembly);
Company = reader.Company;
Product = reader.Product;
Value = new TValue();
Value.PropertyChanged += WhenChanged;
_autosaver.AutoReset = false;
_autosaver.Elapsed += WhenElapsed;
_dispose = new OnceAction <bool>(Dispose);
}
public void TestMethod()
{
AssemblyInfo assemblyInfo = AssemblyReader.GetAssemblyInfo(@".\MSTest_AssemblyReader.dll");
Assert.AreEqual("MSTest_AssemblyReader", assemblyInfo.Name);
Assert.AreEqual(1, assemblyInfo.Namespaces.Count);
Assert.AreEqual("MSTest_AssemblyReader", assemblyInfo.Namespaces[0].Name);
Assert.AreEqual(2, assemblyInfo.Namespaces[0].Classes.Count);
Assert.AreEqual("MSTest_AssemblyReader.UnitTest", assemblyInfo.Namespaces[0].Classes[1].Name);
Assert.AreEqual(3, assemblyInfo.Namespaces[0].Classes[1].Members.Count);
Assert.AreEqual("Int32 intValue", assemblyInfo.Namespaces[0].Classes[1].Members[0].Values[0]);
Assert.AreEqual("System.String stringValue", assemblyInfo.Namespaces[0].Classes[1].Members[1].Values[0]);
Assert.AreEqual("Void Method()", assemblyInfo.Namespaces[0].Classes[1].Members[2].Values[2]);
Assert.AreEqual("Int32 ExtensionMethod(MSTest_AssemblyReader.UnitTest, Int32, Int32)",
assemblyInfo.Namespaces[0].Classes[1].Members[2].Values[10]);
}
/// <summary>
/// Uses reflection to look for and return a .NET type in the DbContext that is managed by the NKitDbRepository.
/// The search is done by looking in the assembly and namespace configured in EntityFrameworkModelsAssembly and EntityFrameworkModelsNamespace settings of the NKitDbRepositorySettings section of the appsettings.json file.
/// Returns the .NET entity type from the DbContext. Throws an exception if it is not found.
/// </summary>
/// <param name="entityName">The name of the entity type to look for.</param>
protected virtual Type GetEntityType(string entityName)
{
Type result = AssemblyReader.FindType(_dbRepositorySettings.EntityFrameworkModelsAssembly, _dbRepositorySettings.EntityFrameworkModelsNamespace, entityName, false);
if (result == null) //If the entity type was not found in the specified models assembly and namespace, look for entity type in the current executing assembly in the default core rest models namespace.
{
string currentAssemblyName = Path.GetFileName(Assembly.GetExecutingAssembly().CodeBase);
string RestApiModelsNamespace = typeof(NKitBaseModel).Namespace;
result = AssemblyReader.FindType(currentAssemblyName, RestApiModelsNamespace, entityName, false);
}
if (result == null)
{
throw new NullReferenceException(string.Format("Could not find entity with name {0}.", entityName));
}
return(result);
}
public static bool CompareAssemblies (string a, string b, bool ignore_cache = false, bool compare_guids = false)
{
if (Driver.Force && !ignore_cache) {
#if DEBUG_COMPARE
Console.WriteLine ("Assemblies {0} and {1} are considered different because -f was passed to " + NAME + ".", a, b);
#endif
return false;
}
if (!File.Exists (b)) {
#if DEBUG_COMPARE
Console.WriteLine ("Assemblies {0} and {1} are considered different because the latter doesn't exist.", a, b);
#endif
return false;
}
using (var astream = new AssemblyReader (a) { CompareGUIDs = compare_guids }) {
using (var bstream = new AssemblyReader (b) { CompareGUIDs = compare_guids }) {
bool rv;
#if DEBUG_COMPARE
Console.WriteLine ("Comparing assemblies {0} and {1}...", a, b);
#endif
rv = CompareStreams (astream, bstream, ignore_cache);
#if DEBUG_COMPARE
Console.WriteLine (" > {0}", rv ? "Identical" : "Different");
#endif
return rv;
}
}
}
public void CreateReader()
{
rdr = new AssemblyReader( this.GetType().Assembly );
}
public string Get(string testAssembly)
{
var locator = new AssemblyReader();
return Get(locator.GetPlatform(testAssembly), locator.GetTargetFramework(testAssembly));
}
public bool ContainsTestsFor(string assembly)
{
var parser = new AssemblyReader();
return parser.GetReferences(assembly).Contains("Microsoft.VisualStudio.QualityTools.UnitTestFramework");
}
public bool ContainsTestsFor(string assembly)
{
var parser = new AssemblyReader();
return parser.GetReferences(assembly).Contains("nunit.framework");
}
