private static bool IsMethodSkipped(ResolvedInjectionConfiguration resolvedConfiguration, string skippedMethodFullName)
{
return(resolvedConfiguration
.InjecteeAssemblies
.SelectMany(assembly => assembly.InjecteeMethods)
.All(method => method.GetFullSimpleName() != skippedMethodFullName));
}
private static bool IsTypeSkipped(ResolvedInjectionConfiguration resolvedConfiguration, string skippedTypeFullName)
{
return(resolvedConfiguration
.InjecteeAssemblies
.SelectMany(assembly => assembly.InjecteeMethods)
.All(method => method.DeclaringType.FullName != skippedTypeFullName));
}
protected static void ExecuteSimpleInjection(InjectionConfiguration configuration)
{
ResolvedInjectionConfiguration resolvedConfiguration =
ResolvedInjectionConfigurationLoader.LoadFromInjectionConfiguration(configuration);
IntegrationTestsHelper.ExecuteInjection(resolvedConfiguration);
IntegrationTestsHelper.WriteModifiedAssembliesIfRequested(resolvedConfiguration);
}
public static void WriteModifiedAssembliesIfRequested(ResolvedInjectionConfiguration resolvedConfiguration)
{
if (TestContext.CurrentContext.Test.Properties.Get(nameof(SaveModifiedAssembliesAttribute).RemoveAttribute()) is bool saveModifiedAssemblies && saveModifiedAssemblies)
{
foreach (ResolvedInjecteeAssembly injecteeAssembly in resolvedConfiguration.InjecteeAssemblies)
{
injecteeAssembly.AssemblyDefinition.Write(injecteeAssembly.AssemblyDefinition.MainModule.FullyQualifiedName);
}
}
}
public void IgnoreTypeAndChildTypesTest()
{
ResolvedInjectionConfiguration resolvedConfiguration =
ExecuteSimpleIgnoreTypeTest(
typeof(TestInjectee).FullName,
IgnoredMemberReferenceFlags.SkipTypes |
IgnoredMemberReferenceFlags.MatchAncestors
);
Assert.True(IsTypeSkipped(resolvedConfiguration, typeof(ChildTestInjectee).FullName));
}
private ResolvedInjectionConfiguration ExecuteSimpleIgnoreTypeTest(
string ignoredTypeFullName,
IgnoredMemberReferenceFlags ignoreFlags =
IgnoredMemberReferenceFlags.SkipTypes
)
{
ResolvedInjectionConfiguration resolvedConfiguration = ExecuteSimpleIgnoreTest(ignoredTypeFullName, ignoreFlags);
Assert.True(IsTypeSkipped(resolvedConfiguration, ignoredTypeFullName));
return(resolvedConfiguration);
}
protected static ResolvedInjectionConfiguration ExecuteSimpleTest(
InjectionConfiguration configuration,
string[] injecteeMethodNames,
bool assertFirstMethodMatch = true)
{
ResolvedInjectionConfiguration resolvedConfiguration =
IntegrationTestsHelper.GetBasicResolvedInjectionConfiguration(configuration, injecteeMethodNames);
ExecuteSimpleTest(resolvedConfiguration, assertFirstMethodMatch);
return(resolvedConfiguration);
}
public void IgnoreVirtualMethodTest()
{
string methodName = $"{typeof(TestInjectee).FullName}.{nameof(TestInjectee.VirtualSingleStatement)}";
string methodNameChild = $"{typeof(ChildTestInjectee).FullName}.{nameof(TestInjectee.VirtualSingleStatement)}";
ResolvedInjectionConfiguration configuration =
ExecuteSimpleIgnoreTest(
methodName,
IgnoredMemberReferenceFlags.SkipMethods
);
Assert.True(IsMethodSkipped(configuration, methodName));
Assert.False(IsMethodSkipped(configuration, methodNameChild));
}
public void IgnoreVirtualPropertyTest()
{
string propertyName = $"{typeof(TestInjectee).FullName}.{nameof(TestInjectee.VirtualSingleStatementProperty)}";
string propertyNameChild = $"{typeof(ChildTestInjectee).FullName}.{nameof(TestInjectee.VirtualSingleStatementProperty)}";
ResolvedInjectionConfiguration configuration =
ExecuteSimpleIgnoreTest(
propertyName,
IgnoredMemberReferenceFlags.SkipProperties
);
Assert.True(IsPropertySkipped(configuration, propertyName));
Assert.False(IsPropertySkipped(configuration, propertyNameChild));
}
private ResolvedInjectionConfiguration ExecuteIgnoreTest(
params IIgnoredMemberReference[] ignoredMemberReferences
)
{
InjectionConfiguration configuration = GetInjectionConfiguration(ignoredMemberReferences.ToList());
// Strip includes
configuration = StripIncludesFromConfiguration(configuration);
ResolvedInjectionConfiguration resolvedConfiguration =
ResolvedInjectionConfigurationLoader.LoadFromInjectionConfiguration(configuration);
ExecuteSimpleTest(resolvedConfiguration, false);
return(resolvedConfiguration);
}
public void IgnoreTypeByRegexTest()
{
ResolvedInjectionConfiguration resolvedConfiguration =
ExecuteIgnoreTest(
new IgnoredMemberReference(
"Injecte[ed]",
IgnoredMemberReferenceFlags.SkipTypes |
IgnoredMemberReferenceFlags.IsRegex |
IgnoredMemberReferenceFlags.MatchAncestors
)
);
Assert.True(IsTypeSkipped(resolvedConfiguration, typeof(TestInjectee).FullName));
Assert.True(IsTypeSkipped(resolvedConfiguration, typeof(ChildTestInjectee).FullName));
Assert.True(IsTypeSkipped(resolvedConfiguration, typeof(StructTestInjectee).FullName));
}
private ResolvedInjectionConfiguration ExecuteSimpleIgnoreTest(
string ignoredMethodFullName,
IgnoredMemberReferenceFlags ignoreFlags = IgnoredMemberReferenceFlags.SkipMethods
)
{
IIgnoredMemberReference[] ignoredMemberReferences =
{
new IgnoredMemberReference(
ignoredMethodFullName,
ignoreFlags
),
};
ResolvedInjectionConfiguration resolvedConfiguration = ExecuteIgnoreTest(ignoredMemberReferences);
return(resolvedConfiguration);
}
protected static void ExecuteSimpleTest(ResolvedInjectionConfiguration resolvedConfiguration, bool assertFirstMethodMatch = true)
{
IntegrationTestsHelper.ExecuteInjection(resolvedConfiguration);
IntegrationTestsHelper.WriteModifiedAssembliesIfRequested(resolvedConfiguration);
if (assertFirstMethodMatch)
{
bool validReferenceOutput = TestContext.CurrentContext.Test.Properties.Get(nameof(ValidReferenceOutputAttribute).RemoveAttribute()) is bool tmp1 && tmp1;
bool forceRegenerateReferenceOutput = TestContext.CurrentContext.Test.Properties.Get(nameof(ForceRegenerateReferenceOutputAttribute).RemoveAttribute()) is bool tmp2 && tmp2;
if (validReferenceOutput && !forceRegenerateReferenceOutput)
{
IntegrationTestsHelper.AssertFirstMethod(resolvedConfiguration);
}
else
{
IntegrationTestsHelper.WriteReferenceOutputFile(resolvedConfiguration);
Console.WriteLine(IntegrationTestsHelper.GetFormattedReferenceOutputFile());
Assert.Fail("Reference output not validated");
}
}
}
private static bool IsPropertySkipped(ResolvedInjectionConfiguration resolvedConfiguration, string skippedPropertyFullName)
{
IEnumerable <PropertyDefinition> allProperties =
resolvedConfiguration
.InjecteeAssemblies
.SelectMany(assembly => assembly.AssemblyDefinition.MainModule.GetAllTypes().SelectMany(type => type.Properties));
PropertyDefinition skippedProperty =
allProperties
.First(property => property.GetFullSimpleName() == skippedPropertyFullName);
if (skippedProperty.GetMethod != null && !IsMethodSkipped(resolvedConfiguration, skippedProperty.GetMethod.GetFullSimpleName()))
{
return(false);
}
if (skippedProperty.SetMethod != null && !IsMethodSkipped(resolvedConfiguration, skippedProperty.SetMethod.GetFullSimpleName()))
{
return(false);
}
return(true);
}
private void ExecuteInjection()
{
#if !DEBUG
try {
#endif
string serializedInjectorConfiguration;
if (_commandLineOptions.ReadConfigurationFromStandardInput)
{
serializedInjectorConfiguration = Console.In.ReadToEnd();
}
else
{
if (!File.Exists(_commandLineOptions.ConfigurationFilePath))
{
throw new MethodInlineInjectorException(
"Injection configuration file doesn't exists",
new FileNotFoundException(_commandLineOptions.ConfigurationFilePath)
);
}
serializedInjectorConfiguration = File.ReadAllText(_commandLineOptions.ConfigurationFilePath);
}
Log.Debug($"Input configuration:{Environment.NewLine}{serializedInjectorConfiguration}");
if (String.IsNullOrWhiteSpace(serializedInjectorConfiguration))
{
throw new MethodInlineInjectorException("Injector configuration is empty");
}
Log.Info("Parsing configuration file");
ValidateConfiguration(serializedInjectorConfiguration);
InjectionConfiguration injectionConfiguration =
SimpleXmlSerializationUtility.XmlDeserializeFromString <InjectionConfiguration>(serializedInjectorConfiguration);
Log.Info("Resolving configuration file");
ResolvedInjectionConfiguration resolvedInjectionConfiguration =
ResolvedInjectionConfigurationLoader.LoadFromInjectionConfiguration(injectionConfiguration);
Log.Info("Starting injection");
MethodInlineInjector assemblyMethodInjector = new MethodInlineInjector(resolvedInjectionConfiguration);
int injectedMethodCount = 0;
assemblyMethodInjector.BeforeMethodInjected += tuple => injectedMethodCount++;
assemblyMethodInjector.Inject();
Log.InfoFormat("Injected {0} methods", injectedMethodCount);
Log.Info("Writing modified assemblies");
foreach (ResolvedInjecteeAssembly injecteeAssembly in resolvedInjectionConfiguration.InjecteeAssemblies)
{
string path = injecteeAssembly.AssemblyDefinition.MainModule.FullyQualifiedName;
Log.DebugFormat("Writing assembly {0} to '{1}'", injecteeAssembly.AssemblyDefinition.FullName, path);
injecteeAssembly.AssemblyDefinition.Write(path);
}
#if !DEBUG
}
catch (MethodInlineInjectorException e) {
string message = "Fatal error: " + e;
if (e.InnerException != null)
{
message += Environment.NewLine;
message += "Error details: ";
message += e.InnerException;
}
Log.Fatal(message);
Environment.ExitCode = 1;
}
#endif
}
public static void WriteReferenceOutputFile(ResolvedInjectionConfiguration resolvedInjectionConfiguration)
{
WriteReferenceOutputFile(resolvedInjectionConfiguration.InjecteeAssemblies[0].InjecteeMethods[0]);
}
public static void AssertFirstMethod(ResolvedInjectionConfiguration resolvedInjectionConfiguration)
{
AssertMethod(resolvedInjectionConfiguration.InjecteeAssemblies[0].InjecteeMethods[0]);
}
public static void ExecuteInjection(ResolvedInjectionConfiguration resolvedInjectionConfiguration)
{
MethodInlineInjector assemblyMethodInjector = new MethodInlineInjector(resolvedInjectionConfiguration);
assemblyMethodInjector.Inject();
}
