private static void VerifyContextWithAdditionalReferences(CompilationAssemblyResolverDependencyContext dc
, string expectedPath, StringComparison comparisonType, Action <Assembly> verification)
{
var attemptedAssemblyResolution = dc.AssertNotNull()[expectedPath.AssertNotNull().AssertNotEmpty(), comparisonType];
verification.AssertNotNull().Invoke(attemptedAssemblyResolution);
}
public void Resolvers_Correct_After_Standalone_Reference_Added()
{
void Verify(string path, ref CompilationAssemblyResolverDependencyContext dc
, Action <CompositeCompilationAssemblyResolver, ICompilationAssemblyResolver[]> verify)
{
path = GetFullPath(path.AssertFileExists());
dc = dc ?? DefaultContext.AssertTrue(x => x.AssertNotNull().Context.AssertNotNull() != null);
var ac = dc;
ac.AssertSame(dc);
ac.AddDependency(path.AssertFileExists());
var actualResolver = ac.Resolver.AssertNotNull();
// TODO: TBD: a deeper question here is this: should ReferenceAssemblyPathResolver/PackageCompilationAssemblyResolver happen with every added dependency? or just the first one?
// TODO: TBD: might be worth reviewing the original code and determine how that was done... and/or contact the author(s) to determine the finer points...
// With deeper levels simply walking lambda arguments to the next letters.
actualResolver.AssertReflectedField(InternalResolvers, InternalResolversBindingFlags, verify);
}
CompilationAssemblyResolverDependencyContext actualContext = null;
void Verification(CompositeCompilationAssemblyResolver v, ICompilationAssemblyResolver[] f)
{
f.AssertNotNull().AssertNotEmpty().AssertTrue(x => x.Length == 2);
f[0].AssertNotNull().AssertIsType <CompositeCompilationAssemblyResolver>()
.AssertReflectedField(InternalResolvers, InternalResolversBindingFlags
, (CompositeCompilationAssemblyResolver w, ICompilationAssemblyResolver[] g) =>
{
g.AssertNotNull().AssertNotEmpty().AssertTrue(x => x.Length == 2);
g[0].AssertNotNull().AssertIsType <ReferenceAssemblyPathResolver>();
g[1].AssertNotNull().AssertIsType <PackageCompilationAssemblyResolver>();
});
f[1].AssertNotNull().AssertIsType <AppBaseCompilationAssemblyResolver>();
}
var firstPath = KingdomSimpleCalculatorsPath.AssertNotNull().AssertNotEmpty();
// TODO: TBD: consider refactoring a general use private static method for use with both standalone and chaining dependencies...
Verify(firstPath, ref actualContext, Verification);
var expectedContextContext = actualContext.Context.AssertNotNull();
actualContext.AssertNotNull();
Verify(firstPath.AssertNotNull().AssertNotEmpty(), ref actualContext, Verification);
actualContext.AssertNotNull().Context.AssertNotNull().AssertSame(expectedContextContext);
expectedContextContext.AssertTrue(
x => x.CompileLibraries.Any(y => HasLibrary(y, firstPath)) ||
x.RuntimeLibraries.Any(y => HasLibrary(y, firstPath))
);
}
/// <summary>
/// Internal Constructor.
/// </summary>
/// <param name="outputDirectory">The Output Directory.</param>
/// <param name="registryFileName">The Registry File Name.</param>
/// <param name="additionalReferencePaths">The Additional Reference Paths.</param>
/// <param name="searchPaths">The Assembly Search Paths.</param>
/// <inheritdoc />
internal AssemblyReferenceServiceManager(string outputDirectory, string registryFileName
, IReadOnlyCollection <string> additionalReferencePaths, IReadOnlyCollection <string> searchPaths)
: base(outputDirectory, registryFileName, () => AssemblyDescriptorRegistryJsonConverter.Converter)
{
Verify.Operation(additionalReferencePaths != null, FormatVerifyOperationMessage(nameof(additionalReferencePaths)));
Verify.Operation(searchPaths != null, FormatVerifyOperationMessage(nameof(searchPaths)));
AdditionalReferencePaths = additionalReferencePaths;
SearchPaths = searchPaths;
PrivateDependencyContext = new CompilationAssemblyResolverDependencyContext(additionalReferencePaths);
}
public void Resolvers_Correct_After_Dependency_References_Added()
{
void Verify(string path, ref CompilationAssemblyResolverDependencyContext dc
, Action <CompositeCompilationAssemblyResolver, ICompilationAssemblyResolver[]> verify)
{
path = GetFullPath(path.AssertFileExists());
dc = dc ?? DefaultContext.AssertTrue(x => x.AssertNotNull().Context.AssertNotNull() != null);
var ac = dc;
ac.AssertSame(dc);
ac.AddDependency(path.AssertFileExists());
var actualResolver = ac.Resolver.AssertNotNull();
actualResolver.AssertReflectedField(InternalResolvers, InternalResolversBindingFlags, verify);
}
// TODO: TBD: first of all... this is correct? As we fold in more references, the resolution folds in on itself?
CompilationAssemblyResolverDependencyContext actualContext = null;
void BaseVerification(CompositeCompilationAssemblyResolver v, ICompilationAssemblyResolver[] f)
{
f.AssertNotNull().AssertNotEmpty().AssertTrue(x => x.Length == 2);
f[0].AssertNotNull().AssertIsType <CompositeCompilationAssemblyResolver>()
.AssertReflectedField(InternalResolvers, InternalResolversBindingFlags
, (CompositeCompilationAssemblyResolver w, ICompilationAssemblyResolver[] g) =>
{
g.AssertNotNull().AssertNotEmpty().AssertTrue(x => x.Length == 2);
g[0].AssertNotNull().AssertIsType <ReferenceAssemblyPathResolver>();
g[1].AssertNotNull().AssertIsType <PackageCompilationAssemblyResolver>();
});
f[1].AssertNotNull().AssertIsType <AppBaseCompilationAssemblyResolver>();
}
var firstPath = KingdomSimpleServicesDefinitionsPath.AssertNotNull().AssertNotEmpty();
// With deeper levels simply walking lambda arguments to the next letters.
Verify(firstPath, ref actualContext, BaseVerification);
var expectedContextContext = actualContext.Context.AssertNotNull();
expectedContextContext.AssertTrue(
x => x.CompileLibraries.Any(y => HasLibrary(y, firstPath)) ||
x.RuntimeLibraries.Any(y => HasLibrary(y, firstPath))
);
var secondPath = KingdomSimpleServicesPath.AssertNotNull().AssertNotEmpty();
Verify(secondPath, ref actualContext
, (v, f) =>
{
f.AssertNotNull().AssertNotEmpty();
f.AssertTrue(x => x.Length == 2);
f[0].AssertNotNull().AssertIsType <CompositeCompilationAssemblyResolver>()
.AssertReflectedField(InternalResolvers, InternalResolversBindingFlags
, (CompositeCompilationAssemblyResolver w, ICompilationAssemblyResolver[] g) =>
{
g.AssertNotNull().AssertNotEmpty().AssertTrue(x => x.Length == 2);
g[0].AssertIsType <CompositeCompilationAssemblyResolver>()
.AssertReflectedField(InternalResolvers, InternalResolversBindingFlags
, (CompositeCompilationAssemblyResolver x, ICompilationAssemblyResolver[] h) =>
{
h.AssertNotNull().AssertNotEmpty().AssertTrue(y => y.Length == 2);
h[0].AssertNotNull().AssertIsType <ReferenceAssemblyPathResolver>();
h[1].AssertNotNull().AssertIsType <PackageCompilationAssemblyResolver>();
});
g[1].AssertNotNull().AssertIsType <AppBaseCompilationAssemblyResolver>();
});
f[1].AssertNotNull().AssertIsType <AppBaseCompilationAssemblyResolver>();
});
var actualContextContext = actualContext.AssertNotNull().Context.AssertNotNull();
actualContextContext.AssertNotSame(expectedContextContext);
actualContextContext.AssertTrue(
x => x.CompileLibraries.Any(y => HasLibrary(y, secondPath)) ||
x.RuntimeLibraries.Any(y => HasLibrary(y, secondPath))
);
}