static AsyncCodeConfiguration Configure()
{
var xmlConfig = new FileInfo("AsyncGenerator.xml");
if (xmlConfig.Exists)
{
using (var stream = xmlConfig.OpenRead())
{
return(AsyncCodeConfiguration.Create()
.LoggerFactory(new Log4NetLoggerFactory())
.ConfigureFromStream <XmlFileConfigurator>(stream, Environment.CurrentDirectory));
}
}
var ymlConfig = new FileInfo("AsyncGenerator.yml");
if (ymlConfig.Exists)
{
using (var stream = ymlConfig.OpenRead())
{
return(AsyncCodeConfiguration.Create()
.LoggerFactory(new Log4NetLoggerFactory())
.ConfigureFromStream <YamlFileConfigurator>(stream, Environment.CurrentDirectory));
}
}
return(null);
}
public async Task TestNullableRestoreDirective()
{
var ignore = false;
var config = AsyncCodeConfiguration.Create()
.ConfigureProject(GetTestProjectPath("NullableRestore"), p => p
.ConfigureAnalyzation(a => a
.MethodConversion(s => MethodConversion.Smart)
.CancellationTokens(true))
.ConfigureTransformation(t => t
.AfterTransformation(result =>
{
if (((CSharpCompilationOptions)result.Project.CompilationOptions).NullableContextOptions == NullableContextOptions.Disable)
{
ignore = true;
return;
}
AssertValidAnnotations(result);
Assert.AreEqual(1, result.Documents.Count);
var document = result.Documents[0];
Assert.NotNull(document.OriginalModified);
Assert.AreEqual(GetOutputFile("NullableRestore"), document.Transformed.ToFullString());
}))
.ApplyChanges(false));
await AsyncCodeGenerator.GenerateAsync(config);
if (ignore)
{
Assert.Ignore("Nullable is not enabled.");
}
}
public async Task GenerateAsync(AsyncCodeConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
foreach (var config in configuration.SolutionConfigurations)
{
var solutionData = await CreateSolutionData(config).ConfigureAwait(false);
foreach (var projectData in solutionData.ProjectData.Values)
{
// Initialize plugins
foreach (var registeredPlugin in projectData.Configuration.RegisteredPlugins)
{
await registeredPlugin.Initialize(projectData.Project).ConfigureAwait(false);
}
// Analyze project
var analyzeConfig = projectData.Configuration.AnalyzeConfiguration;
var analyzationResult = await AnalyzeProject(projectData).ConfigureAwait(false);
foreach (var action in analyzeConfig.Callbacks.AfterAnalyzation)
{
action(analyzationResult);
}
// Transform documents
var transformConfig = projectData.Configuration.TransformConfiguration;
//TransformProject(analyzationResult, transformConfig);
}
}
//conf.SolutionConfigurations.First().ProjectConfigurations.First().TransformConfiguration.
}
public Task TestProject()
{
var config = AsyncCodeConfiguration.Create()
.ConfigureProject(GetTestProjectPath("MultiTargetFrameworks"), p => p
.TargetFramework("net461")
.ApplyChanges(false)
.RegisterPlugin <NUnitAsyncCounterpartsFinder>());
return(AsyncCodeGenerator.GenerateAsync(config));
}
public Task TestYamlAfterTransformation()
{
var configPath = Path.GetFullPath(Path.Combine(GetExternalProjectDirectory("NHibernate"), "src", "AsyncGenerator.yml"));
var config = AsyncCodeConfiguration.Create()
.LoggerFactory(new Log4NetLoggerFactory())
.ConfigureFromFile <YamlFileConfigurator>(configPath);
return(AsyncCodeGenerator.GenerateAsync(config));
}
public Task TestSolution()
{
var config = AsyncCodeConfiguration.Create()
.ConfigureSolution(GetTestSolutionPath("MultiTargetFrameworks"), s => s
.TargetFramework("net461")
.ApplyChanges(false)
.ConfigureProject("MultiTargetFrameworks", p => p
.RegisterPlugin(new NUnitPlugin(false))));
return(AsyncCodeGenerator.GenerateAsync(config));
}
public Task TestYamlProjectConfigurationAfterTransformation()
{
var asm = Assembly.GetExecutingAssembly();
var resource = $"{GetType().Namespace}.ProjectConfiguration.yml";
var stream = asm.GetManifestResourceStream(resource);
var config = AsyncCodeConfiguration.Create()
.LoggerFactory(new Log4NetLoggerFactory())
.ConfigureFromStream <YamlFileConfigurator>(stream);
return(AsyncCodeGenerator.GenerateAsync(config));
}
public virtual AsyncCodeConfiguration Configure(Action <IFluentProjectConfiguration> action = null)
{
var filePath = Path.GetFullPath(Path.Combine(GetBaseDirectory(), "..", "..", "..", "AsyncGenerator.Tests.csproj"));
return(AsyncCodeConfiguration.Create()
.ConfigureProject(filePath, p =>
{
p.ConfigureAnalyzation(a => a
.DocumentSelection(o => string.Join("/", o.Folders) == InputFolderPath)
);
action?.Invoke(p);
})
);
}
public AsyncCodeConfiguration Configure(string fileName, Action <IFluentProjectConfiguration> action = null)
{
var slnFilePath = Path.GetFullPath(Path.Combine(GetBaseDirectory(), "..", "..", "..", "..", "AsyncGenerator.sln"));
return(AsyncCodeConfiguration.Create()
.ConfigureSolution(slnFilePath, c => c
.ConfigureProject("AsyncGenerator.Tests", p =>
{
p.ConfigureAnalyzation(a => a
.DocumentSelection(o => string.Join("/", o.Folders) == InputFolderPath && o.Name == fileName + ".cs")
);
action?.Invoke(p);
})
));
}
public AsyncCodeConfiguration Configure(Action <IProjectConfiguration> action = null)
{
var slnFilePath = Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory + @"..\..\..\..\AsyncGenerator.sln");
return(AsyncCodeConfiguration.Create()
.ConfigureSolution(slnFilePath, c => c
.ConfigureProject("AsyncGenerator.Tests", p =>
{
p.ConfigureAnalyzation(a => a
.DocumentSelection(o => string.Join("/", o.Folders) == FolderPath && o.Name == FileName + ".cs")
//.ScanMethodBody(true)
);
action?.Invoke(p);
})
));
}
public async Task TestCS0103LocalizationAfterTransformation(string culture)
{
var origUiCluture = CultureInfo.CurrentUICulture;
try
{
var cultureInfo = CultureInfo.GetCultureInfo(culture);
CultureInfo.CurrentUICulture = cultureInfo;
CultureInfo.DefaultThreadCurrentUICulture = cultureInfo;
await AsyncCodeGenerator.GenerateAsync(AsyncCodeConfiguration.Create()
.ConfigureProject(GetTestProjectPath("Localization"), o => o
.ConfigureAnalyzation(a => a
.CancellationTokens(true)
.DocumentSelection(d => d.Name == "PrivateMethods.cs")
.MethodConversion(symbol => symbol.Name == "List" ? MethodConversion.Smart : MethodConversion.Unknown)
)
.ConfigureParsing(p => p
.AddPreprocessorSymbolName("TEST")
)
.ConfigureTransformation(t => t
.AfterTransformation(result =>
{
AssertValidAnnotations(result);
Assert.AreEqual(1, result.Documents.Count);
var document = result.Documents[0];
Assert.NotNull(document.OriginalModified);
Assert.AreEqual(GetOutputFile("PrivateMethods"), document.Transformed.ToFullString());
})
)
.ApplyChanges(false)));
}
finally
{
CultureInfo.CurrentUICulture = origUiCluture;
CultureInfo.DefaultThreadCurrentUICulture = origUiCluture;
}
}
public AsyncCodeConfiguration ConfigureByXml(string xmlConfig, string fileName = null, Action <IFluentProjectConfiguration> action = null)
{
return(AsyncCodeConfiguration.Create()
.ConfigureFromStream(GenerateStreamFromString(xmlConfig), new TestProjectXmlFileConfigurator(InputFolderPath, fileName, action)));
}
public static async Task GenerateAsync(AsyncCodeConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
var logger = configuration.LoggerFactoryInstance.GetLogger(nameof(AsyncCodeGenerator));
logger.Info("Generating async code started");
foreach (var config in configuration.SolutionConfigurations)
{
var workspace = CreateWorkspace(config.TargetFramework);
logger.Info($"Opening solution '{config.Path}' started");
var solution = await OpenSolution(workspace, config.Path,
config.SuppressDiagnosticFailuresPrediactes, logger, cancellationToken).ConfigureAwait(false);
logger.Info($"Opening solution '{config.Path}' completed");
logger.Info("Configuring solution prior analyzation started");
var solutionData = CreateSolutionData(solution, config);
logger.Info("Configuring solution prior analyzation completed");
foreach (var projectData in solutionData.GetProjects())
{
await GenerateProject(projectData, configuration.LoggerFactoryInstance, logger, cancellationToken).ConfigureAwait(false);
}
if (config.ApplyChanges)
{
await ApplyChanges(workspace, solutionData.Solution, logger, cancellationToken).ConfigureAwait(false);
}
workspace.Dispose();
}
foreach (var config in configuration.ProjectConfigurations)
{
var workspace = CreateWorkspace(config.TargetFramework);
logger.Info($"Opening project '{config.Path}' started");
var project = await OpenProject(workspace, config.Path,
config.SuppressDiagnosticFailuresPrediactes, logger, cancellationToken).ConfigureAwait(false);
logger.Info($"Opening project '{config.Path}' completed");
logger.Info("Configuring project prior analyzation started");
var projectData = CreateProjectData(project, config);
logger.Info("Configuring project prior analyzation completed");
await GenerateProject(projectData, configuration.LoggerFactoryInstance, logger, cancellationToken).ConfigureAwait(false);
if (config.ApplyChanges)
{
await ApplyChanges(workspace, projectData.Project.Solution, logger, cancellationToken).ConfigureAwait(false);
}
workspace.Dispose();
}
logger.Info("Generating async code completed");
}
public Task TestAfterTransformation()
{
var slnFilePath = Path.GetFullPath(Path.Combine(GetExternalProjectDirectory("NHibernate"), "src", "NHibernate.sln"));
var config = AsyncCodeConfiguration.Create()
.LoggerFactory(new Log4NetLoggerFactory())
.ConfigureSolution(slnFilePath, s => s
.ConcurrentRun()
.SuppressDiagnosticFailures("NHibernate.Test.VisualBasic.vbproj")
.ConfigureProject("NHibernate", p => p
.ConfigureAnalyzation(a => a
.MethodConversion(GetMethodConversion)
.SearchForAsyncCounterparts(symbol =>
{
switch (symbol.Name)
{
case "GetFieldValue":
case "IsDBNull":
case "WriteLine":
return(false);
}
return(true);
})
.CallForwarding(true)
.CancellationTokens(t => t
.Guards(true)
.ParameterGeneration(symbolInfo =>
{
if (IsPubliclyExposedType(symbolInfo.Symbol.ContainingType) || // For public types generate default parameter
symbolInfo.ImplementedInterfaces.Any(o => IsPubliclyExposedType(o.ContainingType))) // The rule for public types shall be passed to implementors
{
return(MethodCancellationToken.Optional);
}
return(MethodCancellationToken.Required);
})
.RequiresCancellationToken(symbol =>
{
if (IsEventListener(symbol.ContainingType))
{
return(true);
}
return(null); // Leave the decision to the generator
})
)
.ScanMethodBody(true)
)
.ConfigureTransformation(t => t
.AsyncLock("NHibernate.Util.AsyncLock", "LockAsync")
.LocalFunctions(true)
.ConfigureAwaitArgument(false)
.DocumentationComments(d => d
.AddOrReplaceMethodSummary(GetMethodSummary)
)
)
.RegisterPlugin <EmptyRegionRemover>()
.RegisterPlugin <TransactionScopeAsyncFlowAdder>() // Rewrite TransactionScope in AdoNetWithDistributedTransactionFactory
)
.ConfigureProject("NHibernate.DomainModel", p => p
.ConfigureAnalyzation(a => a
.ScanForMissingAsyncMembers(true)
.ScanMethodBody(true)
)
)
.ConfigureProject("NHibernate.Test", p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
if (symbol.GetAttributes().Any(o => o.AttributeClass.Name == "IgnoreAttribute"))
{
return(MethodConversion.Ignore);
}
if (symbol.GetAttributes().Any(o => o.AttributeClass.Name == "TestAttribute"))
{
return(MethodConversion.Smart);
}
return(MethodConversion.Unknown);
})
.AsyncExtensionMethods(e => e
.ProjectFile("NHibernate", "LinqExtensionMethods.cs")
)
.PreserveReturnType(symbol => symbol.GetAttributes().Any(o => o.AttributeClass.Name == "TestAttribute"))
.ScanForMissingAsyncMembers(o => o.AllInterfaces.Any(i => i.ContainingAssembly.Name == "NHibernate"))
.CancellationTokens(t => t
.RequiresCancellationToken(symbol => symbol.GetAttributes().Any(o => o.AttributeClass.Name == "TestAttribute") ? (bool?)false : null))
.ScanMethodBody(true)
.DocumentSelection(doc =>
{
return
// AsQueryable method is called on a retrieved list from db and the result is used elsewhere in code
(!doc.FilePath.EndsWith(@"Linq\MathTests.cs")
// It looks like that GC.Collect works differently with async.
// if "await Task.Yield();" is added after DoLinqInSeparateSessionAsync then the test runs successfully (TODO: discover why)
&& !doc.FilePath.EndsWith(@"Linq\ExpressionSessionLeakTest.cs")
);
})
.TypeConversion(type =>
{
if (type.Name == "NorthwindDbCreator" || // Ignored for performance reasons
type.Name == "ObjectAssert" || // Has a TestFixture attribute but is not a test
type.Name == "LinqReadonlyTestsContext") // SetUpFixture
{
return(TypeConversion.Ignore);
}
if (type.GetAttributes().Any(o => o.AttributeClass.Name == "IgnoreAttribute"))
{
return(TypeConversion.Ignore);
}
if (type.GetAttributes().Any(o => o.AttributeClass.Name == "TestFixtureAttribute"))
{
return(TypeConversion.NewType);
}
var currentType = type;
while (currentType != null)
{
if (currentType.Name == "TestCase")
{
return(TypeConversion.Ignore);
}
currentType = currentType.BaseType;
}
return(TypeConversion.Unknown);
})
)
.RegisterPlugin <TransactionScopeAsyncFlowAdder>()
.RegisterPlugin(new NUnitPlugin(false))
)
.ApplyChanges(true)
);
return(AsyncCodeGenerator.GenerateAsync(config));
}
