public static BindOperation Reflection_Cached()
{
BindOperation bind = Reflection();
bind.Cached = true;
return(bind);
}
public static BindOperation PlatformAssembly_Cached()
{
BindOperation bind = PlatformAssembly();
bind.Cached = true;
bind.ProbedPaths.Clear();
return bind;
}
public static BindOperation PlatformAssembly_Cached()
{
BindOperation bind = PlatformAssembly();
bind.Cached = true;
return(bind);
}
private Assembly ResolveAssembly(AssemblyLoadContext context, AssemblyName assemblyName)
{
if (handlerReturn == HandlerReturn.Null)
{
return(null);
}
string name = handlerReturn == HandlerReturn.RequestedAssembly ? assemblyName.Name : $"{assemblyName.Name}Mismatch";
string assemblyPath = Helpers.GetAssemblyInSubdirectoryPath(name);
if (!File.Exists(assemblyPath))
{
return(null);
}
Assembly asm = context.LoadFromAssemblyPath(assemblyPath);
var bind = new BindOperation()
{
AssemblyName = asm.GetName(),
AssemblyPath = assemblyPath,
AssemblyLoadContext = context == AssemblyLoadContext.Default ? context.Name : context.ToString(),
RequestingAssembly = CoreLibName,
RequestingAssemblyLoadContext = DefaultALC,
Success = true,
ResultAssemblyName = asm.GetName(),
ResultAssemblyPath = asm.Location,
Cached = false
};
Binds.Add(bind);
return(asm);
}
private Assembly ResolveAssembly(AssemblyLoadContext context, AssemblyName assemblyName)
{
if (handlerReturn == HandlerReturn.Null)
{
return(null);
}
string appPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string fileName = handlerReturn == HandlerReturn.RequestedAssembly ? $"{assemblyName.Name}.dll" : $"{assemblyName.Name}Mismatch.dll";
string assemblyPath = Path.Combine(appPath, "DependentAssemblies", fileName);
if (!File.Exists(assemblyPath))
{
return(null);
}
Assembly asm = context.LoadFromAssemblyPath(assemblyPath);
var bind = new BindOperation()
{
AssemblyName = asm.GetName(),
AssemblyPath = assemblyPath,
AssemblyLoadContext = context == AssemblyLoadContext.Default ? context.Name : context.ToString(),
RequestingAssembly = CoreLibName,
RequestingAssemblyLoadContext = DefaultALC,
Success = true,
ResultAssemblyName = asm.GetName(),
ResultAssemblyPath = asm.Location,
Cached = false
};
Binds.Add(bind);
return(asm);
}
private static bool RunSingleTest(MethodInfo method)
{
Console.WriteLine($"Running {method.Name}...");
try
{
BinderTestAttribute attribute = method.GetCustomAttribute <BinderTestAttribute>();
if (!string.IsNullOrEmpty(attribute.TestSetup))
{
MethodInfo setupMethod = method.DeclaringType
.GetMethod(attribute.TestSetup, BindingFlags.Public | BindingFlags.Static);
Assert.IsTrue(setupMethod != null);
setupMethod.Invoke(null, new object[0]);
}
Func <BindOperation> func = (Func <BindOperation>)method.CreateDelegate(typeof(Func <BindOperation>));
using (var listener = new BinderEventListener())
{
BindOperation expected = func();
ValidateSingleBind(listener, expected.AssemblyName.Name, expected);
}
}
catch (Exception e)
{
Console.WriteLine($"Test {method.Name} failed: {e}");
return(false);
}
return(true);
}
private static void ValidateSingleBind(BinderEventListener listener, AssemblyName assemblyName, BindOperation expected)
{
BindOperation[] binds = listener.WaitAndGetEventsForAssembly(assemblyName);
Assert.True(binds.Length == 1, $"Bind event count for {assemblyName} - expected: 1, actual: {binds.Length}");
BindOperation actual = binds[0];
Helpers.ValidateBindOperation(expected, actual);
}
protected override void OnEventWritten(EventWrittenEventArgs data)
{
if (data.EventSource.Name != "Microsoft-Windows-DotNETRuntime")
{
return;
}
object GetData(string name) => data.Payload[data.PayloadNames.IndexOf(name)];
string GetDataString(string name) => GetData(name).ToString();
switch (data.EventName)
{
case "AssemblyLoadStart":
lock (eventsLock)
{
Assert.IsTrue(!bindOperations.ContainsKey(data.ActivityId), "AssemblyLoadStart should not exist for same activity ID ");
var bindOperation = new BindOperation()
{
AssemblyName = new AssemblyName(GetDataString("AssemblyName")),
AssemblyPath = GetDataString("AssemblyPath"),
AssemblyLoadContext = GetDataString("AssemblyLoadContext"),
RequestingAssemblyLoadContext = GetDataString("RequestingAssemblyLoadContext"),
ActivityId = data.ActivityId,
ParentActivityId = data.RelatedActivityId,
Nested = bindOperations.ContainsKey(data.RelatedActivityId)
};
string requestingAssembly = GetDataString("RequestingAssembly");
if (!string.IsNullOrEmpty(requestingAssembly))
{
bindOperation.RequestingAssembly = new AssemblyName(requestingAssembly);
}
bindOperations.Add(data.ActivityId, bindOperation);
}
break;
case "AssemblyLoadStop":
lock (eventsLock)
{
Assert.IsTrue(bindOperations.ContainsKey(data.ActivityId), "AssemblyLoadStop should have a matching AssemblyBindStart");
BindOperation bind = bindOperations[data.ActivityId];
bind.Success = (bool)GetData("Success");
string resultName = GetDataString("ResultAssemblyName");
if (!string.IsNullOrEmpty(resultName))
{
bind.ResultAssemblyName = new AssemblyName(resultName);
}
bind.ResultAssemblyPath = GetDataString("ResultAssemblyPath");
bind.Cached = (bool)GetData("Cached");
bind.Completed = true;
}
break;
}
}
private static bool BindOperationsMatch(BindOperation bind1, BindOperation bind2)
{
try
{
ValidateBindOperation(bind1, bind2);
}
catch (AssertTestException e)
{
return(false);
}
return(true);
}
public static void PlatformAssembly_DefaultALC()
{
Console.WriteLine($"Running {nameof(PlatformAssembly_DefaultALC)}...");
using (var listener = new BinderEventListener())
{
string assemblyName = "System.Xml";
Assembly asm = Assembly.Load(assemblyName);
BindOperation[] binds = listener.WaitAndGetEventsForAssembly(assemblyName);
Assert.True(binds.Length == 1, $"Bind count for {assemblyName} - expected: 1, actual: {binds.Length}");
BindOperation bind = binds[0];
Assert.True(bind.Success, $"Expected bind for {assemblyName} to succeed");
}
}
private static void ValidateSingleBind(BinderEventListener listener, string assemblyName, BindOperation expected)
{
BindOperation[] binds = listener.WaitAndGetEventsForAssembly(assemblyName);
Assert.IsTrue(binds.Length == 1, $"Bind event count for {assemblyName} - expected: 1, actual: {binds.Length}");
BindOperation actual = binds[0];
ValidateAssemblyName(expected.AssemblyName, actual.AssemblyName, nameof(BindOperation.AssemblyName));
Assert.AreEqual(expected.AssemblyPath ?? string.Empty, actual.AssemblyPath, $"Unexpected value for {nameof(BindOperation.AssemblyPath)} on event");
Assert.AreEqual(expected.AssemblyLoadContext, actual.AssemblyLoadContext, $"Unexpected value for {nameof(BindOperation.AssemblyLoadContext)} on event");
ValidateAssemblyName(expected.RequestingAssembly, actual.RequestingAssembly, nameof(BindOperation.RequestingAssembly));
Assert.AreEqual(expected.RequestingAssemblyLoadContext ?? string.Empty, actual.RequestingAssemblyLoadContext, $"Unexpected value for {nameof(BindOperation.RequestingAssemblyLoadContext)} on event");
Assert.AreEqual(expected.Success, actual.Success, $"Unexpected value for {nameof(BindOperation.Success)} on event");
Assert.AreEqual(expected.ResultAssemblyPath ?? string.Empty, actual.ResultAssemblyPath, $"Unexpected value for {nameof(BindOperation.ResultAssemblyPath)} on event");
Assert.AreEqual(expected.Cached, actual.Cached, $"Unexpected value for {nameof(BindOperation.Cached)} on event");
ValidateAssemblyName(expected.ResultAssemblyName, actual.ResultAssemblyName, nameof(BindOperation.ResultAssemblyName));
}
public static void NonExistentAssembly_DefaultALC()
{
Console.WriteLine($"Running {nameof(NonExistentAssembly_DefaultALC)}...");
using (var listener = new BinderEventListener())
{
string assemblyName = "DoesNotExist";
try
{
Assembly.Load(assemblyName);
}
catch { }
BindOperation[] binds = listener.WaitAndGetEventsForAssembly(assemblyName);
Assert.True(binds.Length == 1, $"Bind event count for {assemblyName} - expected: 1, actual: {binds.Length}");
BindOperation bind = binds[0];
Assert.False(bind.Success, $"Expected bind for {assemblyName} to fail");
}
}
private static void ValidateBindOperation(BindOperation expected, BindOperation actual)
{
ValidateAssemblyName(expected.AssemblyName, actual.AssemblyName, nameof(BindOperation.AssemblyName));
Assert.AreEqual(expected.AssemblyPath ?? string.Empty, actual.AssemblyPath, $"Unexpected value for {nameof(BindOperation.AssemblyPath)} on event");
Assert.AreEqual(expected.AssemblyLoadContext, actual.AssemblyLoadContext, $"Unexpected value for {nameof(BindOperation.AssemblyLoadContext)} on event");
Assert.AreEqual(expected.RequestingAssemblyLoadContext ?? string.Empty, actual.RequestingAssemblyLoadContext, $"Unexpected value for {nameof(BindOperation.RequestingAssemblyLoadContext)} on event");
ValidateAssemblyName(expected.RequestingAssembly, actual.RequestingAssembly, nameof(BindOperation.RequestingAssembly));
Assert.AreEqual(expected.Success, actual.Success, $"Unexpected value for {nameof(BindOperation.Success)} on event");
Assert.AreEqual(expected.ResultAssemblyPath ?? string.Empty, actual.ResultAssemblyPath, $"Unexpected value for {nameof(BindOperation.ResultAssemblyPath)} on event");
Assert.AreEqual(expected.Cached, actual.Cached, $"Unexpected value for {nameof(BindOperation.Cached)} on event");
ValidateAssemblyName(expected.ResultAssemblyName, actual.ResultAssemblyName, nameof(BindOperation.ResultAssemblyName));
ValidateHandlerInvocations(expected.AssemblyLoadContextResolvingHandlers, actual.AssemblyLoadContextResolvingHandlers, "AssemblyLoadContextResolving");
ValidateHandlerInvocations(expected.AppDomainAssemblyResolveHandlers, actual.AppDomainAssemblyResolveHandlers, "AppDomainAssemblyResolve");
ValidateNestedBinds(expected.NestedBinds, actual.NestedBinds);
}
private static bool RunSingleTest(MethodInfo method)
{
Console.WriteLine($"[{DateTime.Now:T}] Running {method.Name}...");
try
{
BinderTestAttribute attribute = method.GetCustomAttribute <BinderTestAttribute>();
if (!string.IsNullOrEmpty(attribute.TestSetup))
{
MethodInfo setupMethod = method.DeclaringType
.GetMethod(attribute.TestSetup, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
Assert.True(setupMethod != null);
setupMethod.Invoke(null, new object[0]);
}
var loadsToTrack = new string[]
{
Assembly.GetExecutingAssembly().GetName().Name,
DependentAssemblyName,
$"{DependentAssemblyName}.resources",
SubdirectoryAssemblyName,
$"{SubdirectoryAssemblyName}.resources",
};
if (attribute.AdditionalLoadsToTrack != null)
{
loadsToTrack = loadsToTrack.Union(attribute.AdditionalLoadsToTrack).ToArray();
}
Func <BindOperation> func = (Func <BindOperation>)method.CreateDelegate(typeof(Func <BindOperation>));
using (var listener = new BinderEventListener(loadsToTrack))
{
BindOperation expected = func();
ValidateSingleBind(listener, expected.AssemblyName, expected);
}
}
catch (Exception e)
{
Console.WriteLine($"Test {method.Name} failed: {e}");
return(false);
}
return(true);
}
private BindOperation ParseAssemblyLoadStartEvent(EventWrittenEventArgs data, Func <string, string> getDataString)
{
var bindOperation = new BindOperation()
{
AssemblyName = new AssemblyName(getDataString("AssemblyName")),
AssemblyPath = getDataString("AssemblyPath"),
AssemblyLoadContext = getDataString("AssemblyLoadContext"),
RequestingAssemblyLoadContext = getDataString("RequestingAssemblyLoadContext"),
ActivityId = data.ActivityId,
ParentActivityId = data.RelatedActivityId,
};
string requestingAssembly = getDataString("RequestingAssembly");
if (!string.IsNullOrEmpty(requestingAssembly))
{
bindOperation.RequestingAssembly = new AssemblyName(requestingAssembly);
}
return(bindOperation);
}
public static void ValidateBindOperation(BindOperation expected, BindOperation actual)
{
ValidateAssemblyName(expected.AssemblyName, actual.AssemblyName, nameof(BindOperation.AssemblyName));
Assert.Equal(expected.AssemblyPath ?? string.Empty, actual.AssemblyPath);
Assert.Equal(expected.AssemblyLoadContext, actual.AssemblyLoadContext);
Assert.Equal(expected.RequestingAssemblyLoadContext ?? string.Empty, actual.RequestingAssemblyLoadContext);
ValidateAssemblyName(expected.RequestingAssembly, actual.RequestingAssembly, nameof(BindOperation.RequestingAssembly));
Assert.Equal(expected.Success, actual.Success);
Assert.Equal(expected.ResultAssemblyPath ?? string.Empty, actual.ResultAssemblyPath);
Assert.Equal(expected.Cached, actual.Cached);
ValidateAssemblyName(expected.ResultAssemblyName, actual.ResultAssemblyName, nameof(BindOperation.ResultAssemblyName));
ValidateResolutionAttempts(expected.ResolutionAttempts, actual.ResolutionAttempts);
ValidateHandlerInvocations(expected.AssemblyLoadContextResolvingHandlers, actual.AssemblyLoadContextResolvingHandlers, "AssemblyLoadContextResolving");
ValidateHandlerInvocations(expected.AppDomainAssemblyResolveHandlers, actual.AppDomainAssemblyResolveHandlers, "AppDomainAssemblyResolve");
ValidateLoadFromHandlerInvocation(expected.AssemblyLoadFromHandler, actual.AssemblyLoadFromHandler);
ValidateProbedPaths(expected.ProbedPaths, actual.ProbedPaths);
ValidateNestedBinds(expected.NestedBinds, actual.NestedBinds);
}
protected override void OnEventWritten(EventWrittenEventArgs data)
{
if (data.EventSource.Name != "Microsoft-Windows-DotNETRuntime")
{
return;
}
object GetData(string name) => data.Payload[data.PayloadNames.IndexOf(name)];
string GetDataString(string name) => GetData(name).ToString();
switch (data.EventName)
{
case "AssemblyLoadStart":
lock (eventsLock)
{
Assert.True(!bindOperations.ContainsKey(data.ActivityId), "AssemblyLoadStart should not exist for same activity ID ");
var bindOperation = new BindOperation()
{
AssemblyName = new AssemblyName(GetDataString("AssemblyName")),
ActivityId = data.ActivityId,
ParentActivityId = data.RelatedActivityId,
Nested = bindOperations.ContainsKey(data.RelatedActivityId)
};
bindOperations.Add(data.ActivityId, bindOperation);
}
break;
case "AssemblyLoadStop":
lock (eventsLock)
{
Assert.True(bindOperations.ContainsKey(data.ActivityId), "AssemblyLoadStop should have a matching AssemblyLoadStart");
bindOperations[data.ActivityId].Success = (bool)GetData("Success");
bindOperations[data.ActivityId].Completed = true;
}
break;
}
}
protected override void OnEventWritten(EventWrittenEventArgs data)
{
if (data.EventSource.Name != "Microsoft-Windows-DotNETRuntime")
{
return;
}
object GetData(string name)
{
int index = data.PayloadNames.IndexOf(name);
return(index >= 0 ? data.Payload[index] : null);
};
string GetDataString(string name) => GetData(name) as string;
switch (data.EventName)
{
case "AssemblyLoadStart":
{
BindOperation bindOperation = ParseAssemblyLoadStartEvent(data, GetDataString);
lock (eventsLock)
{
Assert.IsTrue(!bindOperations.ContainsKey(data.ActivityId), "AssemblyLoadStart should not exist for same activity ID ");
bindOperation.Nested = bindOperations.ContainsKey(data.RelatedActivityId);
bindOperations.Add(data.ActivityId, bindOperation);
if (bindOperation.Nested)
{
bindOperations[data.RelatedActivityId].NestedBinds.Add(bindOperation);
}
}
break;
}
case "AssemblyLoadStop":
{
lock (eventsLock)
{
Assert.IsTrue(bindOperations.ContainsKey(data.ActivityId), "AssemblyLoadStop should have a matching AssemblyBindStart");
BindOperation bind = bindOperations[data.ActivityId];
bind.Success = (bool)GetData("Success");
string resultName = GetDataString("ResultAssemblyName");
if (!string.IsNullOrEmpty(resultName))
{
bind.ResultAssemblyName = new AssemblyName(resultName);
}
bind.ResultAssemblyPath = GetDataString("ResultAssemblyPath");
bind.Cached = (bool)GetData("Cached");
bind.Completed = true;
}
break;
}
case "AssemblyLoadContextResolvingHandlerInvoked":
{
HandlerInvocation handlerInvocation = ParseHandlerInvokedEvent(GetDataString);
lock (eventsLock)
{
Assert.IsTrue(bindOperations.ContainsKey(data.ActivityId), "AssemblyLoadContextResolvingHandlerInvoked should have a matching AssemblyBindStart");
BindOperation bind = bindOperations[data.ActivityId];
bind.AssemblyLoadContextResolvingHandlers.Add(handlerInvocation);
}
break;
}
case "AppDomainAssemblyResolveHandlerInvoked":
{
HandlerInvocation handlerInvocation = ParseHandlerInvokedEvent(GetDataString);
lock (eventsLock)
{
Assert.IsTrue(bindOperations.ContainsKey(data.ActivityId), "AppDomainAssemblyResolveHandlerInvoked should have a matching AssemblyBindStart");
BindOperation bind = bindOperations[data.ActivityId];
bind.AppDomainAssemblyResolveHandlers.Add(handlerInvocation);
}
break;
}
}
}
protected override void OnEventWritten(EventWrittenEventArgs data)
{
if (data.EventSource.Name != "Microsoft-Windows-DotNETRuntime")
{
return;
}
object GetData(string name)
{
int index = data.PayloadNames.IndexOf(name);
return(index >= 0 ? data.Payload[index] : null);
};
string GetDataString(string name) => GetData(name) as string;
switch (data.EventName)
{
case "AssemblyLoadStart":
{
BindOperation bindOperation = ParseAssemblyLoadStartEvent(data, GetDataString);
if (!IsLoadToTrack(bindOperation.AssemblyName.Name))
{
return;
}
lock (eventsLock)
{
Assert.IsTrue(!bindOperations.ContainsKey(data.ActivityId), "AssemblyLoadStart should not exist for same activity ID ");
bindOperation.Nested = bindOperations.ContainsKey(data.RelatedActivityId);
bindOperations.Add(data.ActivityId, bindOperation);
if (bindOperation.Nested)
{
bindOperations[data.RelatedActivityId].NestedBinds.Add(bindOperation);
}
}
break;
}
case "AssemblyLoadStop":
{
string assemblyName = GetDataString("AssemblyName");
if (!IsLoadToTrack(new AssemblyName(assemblyName).Name))
{
return;
}
bool success = (bool)GetData("Success");
string resultName = GetDataString("ResultAssemblyName");
lock (eventsLock)
{
if (!bindOperations.ContainsKey(data.ActivityId))
{
Assert.Fail(GetMissingAssemblyBindStartMessage(data, $"Success={success}, Name={resultName}"));
}
BindOperation bind = bindOperations[data.ActivityId];
bind.Success = success;
if (!string.IsNullOrEmpty(resultName))
{
bind.ResultAssemblyName = new AssemblyName(resultName);
}
bind.ResultAssemblyPath = GetDataString("ResultAssemblyPath");
bind.Cached = (bool)GetData("Cached");
bind.Completed = true;
}
break;
}
case "ResolutionAttempted":
{
ResolutionAttempt attempt = ParseResolutionAttemptedEvent(GetData, GetDataString);
if (!IsLoadToTrack(attempt.AssemblyName.Name))
{
return;
}
lock (eventsLock)
{
if (!bindOperations.ContainsKey(data.ActivityId))
{
Assert.Fail(GetMissingAssemblyBindStartMessage(data, attempt.ToString()));
}
BindOperation bind = bindOperations[data.ActivityId];
bind.ResolutionAttempts.Add(attempt);
}
break;
}
case "AssemblyLoadContextResolvingHandlerInvoked":
{
HandlerInvocation handlerInvocation = ParseHandlerInvokedEvent(GetDataString);
if (!IsLoadToTrack(handlerInvocation.AssemblyName.Name))
{
return;
}
lock (eventsLock)
{
if (!bindOperations.ContainsKey(data.ActivityId))
{
Assert.Fail(GetMissingAssemblyBindStartMessage(data, handlerInvocation.ToString()));
}
BindOperation bind = bindOperations[data.ActivityId];
bind.AssemblyLoadContextResolvingHandlers.Add(handlerInvocation);
}
break;
}
case "AppDomainAssemblyResolveHandlerInvoked":
{
HandlerInvocation handlerInvocation = ParseHandlerInvokedEvent(GetDataString);
if (!IsLoadToTrack(handlerInvocation.AssemblyName.Name))
{
return;
}
lock (eventsLock)
{
if (!bindOperations.ContainsKey(data.ActivityId))
{
Assert.Fail(GetMissingAssemblyBindStartMessage(data, handlerInvocation.ToString()));
}
BindOperation bind = bindOperations[data.ActivityId];
bind.AppDomainAssemblyResolveHandlers.Add(handlerInvocation);
}
break;
}
case "AssemblyLoadFromResolveHandlerInvoked":
{
LoadFromHandlerInvocation loadFrom = ParseLoadFromHandlerInvokedEvent(GetData, GetDataString);
if (!IsLoadToTrack(loadFrom.AssemblyName.Name))
{
return;
}
lock (eventsLock)
{
if (!bindOperations.ContainsKey(data.ActivityId))
{
Assert.Fail(GetMissingAssemblyBindStartMessage(data, loadFrom.ToString()));
}
BindOperation bind = bindOperations[data.ActivityId];
bind.AssemblyLoadFromHandler = loadFrom;
}
break;
}
case "KnownPathProbed":
{
ProbedPath probedPath = ParseKnownPathProbedEvent(GetData, GetDataString);
string name = System.IO.Path.GetFileNameWithoutExtension(probedPath.FilePath);
if (!IsLoadToTrack(name.EndsWith(".ni") ? name.Remove(name.Length - 3) : name))
{
return;
}
lock (eventsLock)
{
if (!bindOperations.ContainsKey(data.ActivityId))
{
Assert.Fail(GetMissingAssemblyBindStartMessage(data, probedPath.ToString()));
}
BindOperation bind = bindOperations[data.ActivityId];
bind.ProbedPaths.Add(probedPath);
}
break;
}
}
}
