public void MultidimensionalPrimitiveArray()
{
var arrayDocId = "M:System.Int32[0:,0:][0:,0:].#ctor(System.Int32,System.Int32)";
var objectDocId = "T:System.Object";
var assemblyToTest = TestAssembly.Create("MultidimensionalPrimitiveArray.cs");
var filter = new DotNetFrameworkFilter();
var dependencyFinder = new ReflectionMetadataDependencyFinder(filter, new SystemObjectFinder(filter));
var progressReporter = Substitute.For <IProgressReporter>();
var dependencies = dependencyFinder.FindDependencies(new[] { assemblyToTest }, progressReporter);
var primitiveArray = dependencies.Dependencies.FirstOrDefault(o => string.Equals(o.Key.MemberDocId, arrayDocId, StringComparison.Ordinal)).Key;
Assert.NotNull(primitiveArray);
var systemObject = dependencies.Dependencies.FirstOrDefault(o => string.Equals(o.Key.MemberDocId, objectDocId, StringComparison.Ordinal)).Key;
Assert.NotNull(systemObject);
//Test that the DefinedInAssemblyIdentity of the primitive array is not null/empty and it is the same as the one of System.Object
var definedInAssemblyIdentity = primitiveArray.DefinedInAssemblyIdentity;
var isNullOrWhiteSpace = string.IsNullOrWhiteSpace(definedInAssemblyIdentity);
Assert.False(isNullOrWhiteSpace);
Assert.Equal(systemObject.DefinedInAssemblyIdentity, definedInAssemblyIdentity);
}
/// <summary>
/// Gets a list of the host assembly's referenced assemblies excluding
/// any Microsoft, System, or Mono prefixed assemblies or assemblies with
/// official Microsoft key hashes. Essentially, we get a list of all non
/// Microsoft assemblies here.
/// </summary>
/// <returns></returns>
public static IList <Assembly> GetReferencedAssemblies()
{
// .NET Port Hack: We do a 2-level deep check here because if the assembly you're
// hoping would be loaded hasn't been loaded yet into the app domain,
// it is unavailable. So we go to the next level on each and check each referenced
// assembly.
#if NETSTANDARD
var dependencyContext = DependencyContext.Default;
var assemblyNames = dependencyContext.RuntimeLibraries
.SelectMany(lib => lib.GetDefaultAssemblyNames(dependencyContext))
.Where(x => !DotNetFrameworkFilter.IsFrameworkAssembly(x))
.Distinct();
var assembliesLoaded = LoadAssemblyFromName(assemblyNames);
#else
var assembliesLoaded = AppDomain.CurrentDomain.GetAssemblies();
#endif
assembliesLoaded = assembliesLoaded.Where(x => !DotNetFrameworkFilter.IsFrameworkAssembly(x)).ToArray();
var referencedAssemblies = assembliesLoaded
.SelectMany(assembly =>
{
return(assembly
.GetReferencedAssemblies()
.Where(reference => !DotNetFrameworkFilter.IsFrameworkAssembly(reference))
.Select(assemblyName => LoadAssemblyFromName(assemblyName)));
})
.Where(x => x != null)
.Distinct();
return(assembliesLoaded.Concat(referencedAssemblies).Distinct().ToList());
}
public void VerifyDotNetFrameworkFilter()
{
var filter = new DotNetFrameworkFilter();
var dependencyFinder = new ReflectionMetadataDependencyFinder(filter, new SystemObjectFinder(filter));
var assemblyToTest = TestAssembly.Create("FilterApis.cs");
var expected = FilterApisDocIds
.Concat(new[] {
"M:System.Uri.TryCreate(System.String,System.UriKind,System.Uri@)",
"T:System.Uri",
"T:System.UriKind"
})
.OrderBy(x => x, StringComparer.Ordinal);
var progressReporter = Substitute.For <IProgressReporter>();
var dependencies = dependencyFinder.FindDependencies(new[] { assemblyToTest }, progressReporter);
var foundDocIds = dependencies.Dependencies
.Select(m => m.Key.MemberDocId)
.OrderBy(o => o, StringComparer.Ordinal);
foreach (var docId in foundDocIds)
{
_output.WriteLine(docId);
}
Assert.Equal(expected, foundDocIds);
}
public void EmptyProject()
{
var assemblyToTest = TestAssembly.Create("EmptyProject.cs", _output);
var expected = EmptyProjectMemberDocId();
var filter = new DotNetFrameworkFilter();
var dependencyFinder = new ReflectionMetadataDependencyFinder(filter, new SystemObjectFinder(filter));
var progressReporter = Substitute.For <IProgressReporter>();
var dependencies = dependencyFinder.FindDependencies(new[] { assemblyToTest }, progressReporter);
var foundDocIds = dependencies
.Dependencies
.Select(o => Tuple.Create(o.Key.MemberDocId, o.Value.Count))
.OrderBy(o => o.Item1, StringComparer.Ordinal)
.ToList();
var expectedOrdered = expected
.OrderBy(o => o.Item1, StringComparer.Ordinal)
.ToList();
Assert.Equal(expectedOrdered.Count, foundDocIds.Count);
foreach (var combined in expectedOrdered.Zip(foundDocIds, Tuple.Create))
{
var expectedItem = combined.Item1;
var actualItem = combined.Item2;
Assert.Equal(expectedItem.Item1, actualItem.Item1);
Assert.Equal(expectedItem.Item2, actualItem.Item2);
}
}
/// <summary>
/// Gets a list of the host assembly's referenced assemblies excluding
/// any Microsoft, System, or Mono prefixed assemblies or assemblies with
/// official Microsoft key hashes. Essentially, we get a list of all non
/// Microsoft assemblies here.
/// </summary>
/// <returns></returns>
public static IEnumerable <Assembly> GetReferencedAssemblies()
{
// .NET Port Hack: We do a 2-level deep check here because if the assembly you're
// hoping would be loaded hasn't been loaded yet into the app domain,
// it is unavailable. So we go to the next level on each and check each referenced
// assembly.
var assembliesLoaded = AppDomain.CurrentDomain.GetAssemblies();
var nonFrameworkAssembliesLoaded = assembliesLoaded.Where(x => !DotNetFrameworkFilter.IsFrameworkAssembly(x));
var referencedAssemblies = nonFrameworkAssembliesLoaded
.SelectMany(assembly =>
{
return(assembly
.GetReferencedAssemblies()
.Where(reference => !DotNetFrameworkFilter.IsFrameworkAssembly(reference))
.Select(assemblyName => LoadAssemblyFromName(assemblyName)));
})
.Where(x => x != null)
.Distinct();
return(nonFrameworkAssembliesLoaded.Concat(referencedAssemblies).Distinct());
}
static SPIClassIterator()
{
types = new HashSet <Type>();
// .NET Port Hack: We do a 2-level deep check here because if the assembly you're
// hoping would be loaded hasn't been loaded yet into the app domain,
// it is unavailable. So we go to the next level on each and check each referenced
// assembly.
#if NETSTANDARD
var dependencyContext = DependencyContext.Default;
var assemblyNames = dependencyContext.RuntimeLibraries
.SelectMany(lib => lib.GetDefaultAssemblyNames(dependencyContext))
.Where(x => !DotNetFrameworkFilter.IsFrameworkAssembly(x))
.Distinct();
var assembliesLoaded = LoadAssemblyFromName(assemblyNames);
#else
var assembliesLoaded = AppDomain.CurrentDomain.GetAssemblies();
#endif
assembliesLoaded = assembliesLoaded.Where(x => !DotNetFrameworkFilter.IsFrameworkAssembly(x)).ToArray();
var referencedAssemblies = assembliesLoaded
.SelectMany(assembly =>
{
return(assembly
.GetReferencedAssemblies()
.Where(reference => !DotNetFrameworkFilter.IsFrameworkAssembly(reference))
.Select(assemblyName => LoadAssemblyFromName(assemblyName)));
})
.Where(x => x != null)
.Distinct();
var assembliesToExamine = assembliesLoaded.Concat(referencedAssemblies).Distinct().ToList();
// LUCENENET HACK:
// Tests such as TestImpersonation.cs expect that the assemblies
// are probed in a certain order. NamedSPILoader, lines 68 - 75 adds
// the first item it sees with that name. So if you have multiple
// codecs, it may not add the right one, depending on the order of
// the assemblies that were examined.
// This results in many test failures if Types from Lucene.Net.Codecs
// are examined and added to NamedSPILoader first before
// Lucene.Net.TestFramework.
var testFrameworkAssembly = assembliesToExamine.FirstOrDefault(x => string.Equals(x.GetName().Name, "Lucene.Net.TestFramework", StringComparison.Ordinal));
if (testFrameworkAssembly != null)
{
assembliesToExamine.Remove(testFrameworkAssembly);
assembliesToExamine.Insert(0, testFrameworkAssembly);
}
foreach (var assembly in assembliesToExamine)
{
try
{
foreach (var type in assembly.GetTypes().Where(x => x.GetTypeInfo().IsPublic))
{
try
{
if (!IsInvokableSubclassOf <S>(type))
{
continue;
}
// We are looking for types with a default ctor
// (which is used in NamedSPILoader) or has a single parameter
// of type IDictionary<string, string> (for AnalysisSPILoader)
var matchingCtors = type.GetConstructors().Where(ctor =>
{
var parameters = ctor.GetParameters();
switch (parameters.Length)
{
case 0: // default ctor
return(false); // LUCENENET NOTE: Now that we have factored Codecs into Abstract Factories, we don't need default constructors here
case 1:
return(typeof(IDictionary <string, string>).IsAssignableFrom(parameters[0].ParameterType));
default:
return(false);
}
});
if (matchingCtors.Any())
{
types.Add(type);
}
}
catch
{
// swallow
}
}
}
catch
{
// swallow
}
}
}
static SPIClassIterator()
{
types = new HashSet <Type>();
// .NET Port Hack: We do a 2-level deep check here because if the assembly you're
// hoping would be loaded hasn't been loaded yet into the app domain,
// it is unavailable. So we go to the next level on each and check each referenced
// assembly.
var assembliesLoaded = AppDomain.CurrentDomain.GetAssemblies().Where(x => !DotNetFrameworkFilter.IsFrameworkAssembly(x));
var referencedAssemblies = assembliesLoaded
.SelectMany(assembly =>
{
return(assembly
.GetReferencedAssemblies()
.Where(reference => !DotNetFrameworkFilter.IsFrameworkAssembly(reference))
.Select(assemblyName => {
try
{
return Assembly.Load(assemblyName);
}
catch
{
// swallow
return null;
}
}));
})
.Where(x => x != null)
.Distinct();
var assembliesToExamine = assembliesLoaded.Concat(referencedAssemblies).Distinct();
foreach (var assembly in assembliesToExamine)
{
try
{
foreach (var type in assembly.GetTypes().Where(x => x.IsPublic))
{
try
{
if (!IsInvokableSubclassOf <S>(type))
{
continue;
}
// We are looking for types with a default ctor
// (which is used in NamedSPILoader) or has a single parameter
// of type IDictionary<string, string> (for AnalysisSPILoader)
var matchingCtors = type.GetConstructors().Where(ctor =>
{
var parameters = ctor.GetParameters();
switch (parameters.Length)
{
case 0: // default ctor
return(true);
case 1:
return(typeof(IDictionary <string, string>).IsAssignableFrom(parameters[0].ParameterType));
default:
return(false);
}
});
if (matchingCtors.Any())
{
types.Add(type);
}
}
catch
{
// swallow
}
}
}
catch
{
// swallow
}
}
}
