public async Task ReadonlyTest(string fileName, Action <IFluentProjectConfiguration> action = null)
{
var configuration = Configure(fileName, action).SolutionConfigurations.First();
var solutionData = AsyncCodeGenerator.CreateSolutionData(ReadOnlySolution.Value, configuration);
var project = solutionData.GetProjects().Single();
await AsyncCodeGenerator.GenerateProject(project, LoggerFactory, Logger).ConfigureAwait(false);
}
public Task TestXmlSolution()
{
var config = ConfigureByXml(
$@"
<AsyncGenerator xmlns=""https://github.com/maca88/AsyncGenerator"">
<Solution filePath=""{GetTestSolutionPath("MultiTargetFrameworks")}"">
<ApplyChanges>false</ApplyChanges>
<TargetFramework>net461</TargetFramework>
<Projects>
<Project name=""MultiTargetFrameworks"">
<RegisterPlugin>
<Plugin type=""AsyncGenerator.Core.Plugins.NUnitPlugin"" assemblyName=""AsyncGenerator.Core"">
<Parameters>
<Parameter name=""createNewTypes"" value=""false"" />
</Parameters>
</Plugin>
</RegisterPlugin>
</Project>
</Projects>
</Solution>
</AsyncGenerator>
");
return(AsyncCodeGenerator.GenerateAsync(config));
}
public void TestAfterAnalyzation()
{
var read = GetMethodName(o => o.Read);
var readFile = GetMethodName <DerivedClass>(o => o.ReadFile);
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(3, result.Documents[0].Namespaces[0].Types.Count);
var types = result.Documents[0].Namespaces[0].Types.ToDictionary(o => o.Symbol.Name);
Assert.AreEqual(1, types[nameof(DerivedClass)].Methods.Count);
Assert.AreEqual(MethodConversion.ToAsync, types[nameof(DerivedClass)].Methods[0].Conversion);
Assert.AreEqual(1, types[nameof(BaseClass)].Methods.Count);
Assert.AreEqual(MethodConversion.ToAsync, types[nameof(BaseClass)].Methods[0].Conversion);
};
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(MethodConversion.Smart);
})
.Callbacks(c => c
.AfterAnalyzation(afterAnalyzationFn)
)
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
}
private static Microsoft.CodeAnalysis.Solution OpenSolution()
{
var filePath = Path.GetFullPath(Path.Combine(GetBaseDirectory(), "..", "..", "..", "..", "AsyncGenerator.sln"));
var workspace = AsyncCodeGenerator.CreateWorkspace(null);
return(AsyncCodeGenerator.OpenSolution(workspace, filePath, ImmutableArray <Predicate <string> > .Empty, Logger).GetAwaiter().GetResult());
}
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 void TestAfterAnalyzation()
{
var getData = GetMethodName(o => o.GetData());
var getDataAsync = GetMethodName(o => o.GetDataAsync());
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces[0].Types.Count);
Assert.AreEqual(2, result.Documents[0].Namespaces[0].Types[0].Methods.Count);
var methods = result.Documents[0].Namespaces[0].Types[0].Methods.ToDictionary(o => o.Symbol.Name);
Assert.AreEqual(MethodConversion.Ignore, methods[getData].Conversion);
Assert.AreEqual(MethodConversion.Ignore, methods[getDataAsync].Conversion);
};
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(symbol.Name == getData ? MethodConversion.ToAsync : MethodConversion.Unknown);
})
.Callbacks(c => c
.AfterAnalyzation(afterAnalyzationFn)
)
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
}
public void TestAfterAnalyzation()
{
var noOptimizationSynhronized = GetMethodName(o => o.NoOptimizationSynhronized);
var synhronized = GetMethodName(o => o.Synhronized);
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(2, result.Documents[0].Namespaces[0].Types[0].Methods.Count);
var methods = result.Documents[0].Namespaces[0].Types[0].Methods.ToDictionary(o => o.Symbol.Name);
Assert.IsTrue(methods[noOptimizationSynhronized].MustRunSynchronized);
Assert.IsTrue(methods[synhronized].MustRunSynchronized);
};
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(MethodConversion.ToAsync);
})
.Callbacks(c => c
.AfterAnalyzation(afterAnalyzationFn)
)
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
}
public void TestAfterAnalyzation()
{
var readFile = GetMethodName(o => o.ReadFile);
var callReadFile = GetMethodName(o => o.CallReadFile);
var callCallReadFile = GetMethodName(o => o.CallCallReadFile);
var read = GetMethodName(() => SimpleFile.Read());
var readAsync = GetMethodName(() => SimpleFile.ReadAsync());
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces[0].Types.Count);
Assert.AreEqual(3, result.Documents[0].Namespaces[0].Types[0].Methods.Count);
var methods = result.Documents[0].Namespaces[0].Types[0].Methods.ToDictionary(o => o.Symbol.Name);
Assert.IsTrue(methods[readFile].OmitAsync);
// Check InvokedBy
Assert.AreEqual(1, methods[readFile].InvokedBy.Count);
Assert.AreEqual(methods[callReadFile], methods[readFile].InvokedBy[0]);
Assert.AreEqual(1, methods[callReadFile].InvokedBy.Count);
Assert.AreEqual(0, methods[callCallReadFile].InvokedBy.Count);
// Check MethodReferences
Assert.AreEqual(1, methods[readFile].MethodReferences.Count);
var methodReference = methods[readFile].MethodReferences[0];
Assert.AreEqual(SyntaxKind.InvocationExpression, methodReference.ReferenceNode.Kind());
Assert.IsFalse(methodReference.Ignore);
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsNull(methodReference.ReferenceFunctionData);
Assert.AreEqual(read, methodReference.ReferenceSymbol.Name);
Assert.AreEqual(1, methodReference.ReferenceAsyncSymbols.Count);
Assert.AreEqual(readAsync, methodReference.ReferenceAsyncSymbols[0].Name);
// Check Conversion
Assert.AreEqual(MethodConversion.ToAsync, methods[readFile].Conversion);
Assert.AreEqual(MethodConversion.ToAsync, methods[callReadFile].Conversion);
Assert.AreEqual(MethodConversion.ToAsync, methods[callCallReadFile].Conversion);
};
var methodConversions = new[] { MethodConversion.ToAsync, MethodConversion.Smart };
foreach (var methodConversion in methodConversions)
{
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(symbol.Name == readFile ? methodConversion : MethodConversion.Unknown);
})
.Callbacks(c => c.AfterAnalyzation(afterAnalyzationFn))
)
);
Assert.DoesNotThrowAsync(async() => await generator.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 TestProject()
{
var config = AsyncCodeConfiguration.Create()
.ConfigureProject(GetTestProjectPath("MultiTargetFrameworks"), p => p
.TargetFramework("net461")
.ApplyChanges(false)
.RegisterPlugin <NUnitAsyncCounterpartsFinder>());
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 void TestCustomPreconditionCheckerAfterAnalyzation()
{
var divide = GetMethodName(o => o.Divide(0, 0));
var divideShort = GetMethodName(o => o.DivideShort(0, 0));
var readFile = GetMethodName(o => o.ReadFile(null));
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(2, result.Documents[0].Namespaces[0].Types.Count);
var types = result.Documents[0].Namespaces[0].Types.ToDictionary(o => o.Symbol.Name);
Assert.AreEqual(3, types[nameof(Preconditions)].Methods.Count);
var methods = types[nameof(Preconditions)].Methods.ToDictionary(o => o.Symbol.Name);
Assert.AreEqual(1, methods[readFile].Preconditions.Count);
Assert.AreEqual(1, methods[divideShort].Preconditions.Count);
Assert.AreEqual(1, methods[divide].Preconditions.Count);
foreach (var method in methods.Values)
{
Assert.AreEqual(MethodConversion.ToAsync, method.Conversion);
}
};
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(MethodConversion.Smart);
})
.IsPrecondition((statement, semanticModel) =>
{
var expressionStatement = statement as ExpressionStatementSyntax;
var invocationExpression = expressionStatement?.Expression as InvocationExpressionSyntax;
if (invocationExpression == null)
{
return(false);
}
var symbol = semanticModel.GetSymbolInfo(invocationExpression).Symbol;
return(symbol?.ContainingType?.Name == "Requires");
})
.Callbacks(c => c
.AfterAnalyzation(afterAnalyzationFn)
)
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
}
public static int Main(string[] args)
{
Logger.Info($"AsyncGenerator{Environment.NewLine}");
var cancellationSource = new CancellationTokenSource();
Console.CancelKeyPress += (sender, e) =>
{
Logger.Warn("Canceling operations...");
cancellationSource.Cancel();
};
try
{
EnvironmentHelper.Setup();
var configuration = Configure();
if (configuration == null)
{
Logger.Info("Could not find configuration file:");
Logger.Info($"\t - please make sure that your working directory contains either AsyncGenerator.xml or AsyncGenerator.yml{Environment.NewLine}");
Logger.Info("Working directory:");
Logger.Info($"\t- {Environment.CurrentDirectory}{Environment.NewLine}");
return(1);
}
AsyncCodeGenerator.GenerateAsync(configuration, cancellationSource.Token)
.GetAwaiter()
.GetResult();
return(0);
}
#if !NETCOREAPP2_1
// Print inner exceptions for .NET as they are printed in NETCore 2.1: https://github.com/dotnet/coreclr/pull/15688
catch (ReflectionTypeLoadException e) when(e.LoaderExceptions?.Length > 0)
{
var builder = new StringBuilder();
foreach (var loaderException in e.LoaderExceptions)
{
builder.AppendLine(loaderException.Message);
}
Logger.Fatal(builder.ToString(), e);
return(-1);
}
#endif
catch (Exception e)
{
Logger.Fatal(e);
return(-1);
}
}
public Task TestYamlProject()
{
var config = ConfigureByYaml(
$@"
projects:
- filePath: {GetTestProjectPath("MultiTargetFrameworks")}
targetFramework: net461
applyChanges: false
registerPlugin:
- type: AsyncGenerator.Core.Plugins.NUnitAsyncCounterpartsFinder
assemblyName: AsyncGenerator.Core
");
return(AsyncCodeGenerator.GenerateAsync(config));
}
public void TestAfterAnalyzation()
{
var readFile = GetMethodName(o => o.ReadFile());
var method1 = GetMethodName(o => o.Method1);
var method2 = GetMethodName(o => o.Method2);
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces[0].Types.Count);
Assert.AreEqual(3, result.Documents[0].Namespaces[0].Types[0].Methods.Count);
var methods = result.Documents[0].Namespaces[0].Types[0].Methods.ToDictionary(o => o.Symbol.Name);
Assert.AreEqual(1, methods[readFile].InvokedBy.Count);
var readFileMethod = methods[readFile];
var circularMethods = new[]
{
method1,
method2,
readFile
};
IMethodAnalyzationResult method;
foreach (var circularMethod in circularMethods)
{
method = methods[circularMethod];
Assert.AreEqual(MethodConversion.ToAsync, method.Conversion);
}
};
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(MethodConversion.Smart);
})
.Callbacks(c => c
.AfterAnalyzation(afterAnalyzationFn)
)
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
}
public Task TestXmlProject()
{
var config = ConfigureByXml(
$@"
<AsyncGenerator xmlns=""https://github.com/maca88/AsyncGenerator"">
<Projects>
<Project filePath=""{GetTestProjectPath("MultiTargetFrameworks")}"">
<ApplyChanges>false</ApplyChanges>
<TargetFramework>net461</TargetFramework>
<RegisterPlugin>
<Plugin type=""AsyncGenerator.Core.Plugins.NUnitAsyncCounterpartsFinder"" assemblyName=""AsyncGenerator.Core"" />
</RegisterPlugin>
</Project>
</Projects>
</AsyncGenerator>
");
return(AsyncCodeGenerator.GenerateAsync(config));
}
public Task TestYamlSolution()
{
var config = ConfigureByYaml(
$@"
solution:
filePath: {GetTestSolutionPath("MultiTargetFrameworks")}
targetFramework: net461
applyChanges: false
projects:
- name: MultiTargetFrameworks
registerPlugin:
- type: AsyncGenerator.Core.Plugins.NUnitPlugin
parameters:
- name: createNewTypes
value: false
assemblyName: AsyncGenerator.Core
");
return(AsyncCodeGenerator.GenerateAsync(config));
}
public void TestAfterAnalyzation()
{
var divide = GetMethodName(o => o.Divide(0, 0));
var divideShort = GetMethodName(o => o.DivideShort(0, 0));
var readFile = GetMethodName(o => o.ReadFile(null));
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(2, result.Documents[0].Namespaces[0].Types.Count);
var types = result.Documents[0].Namespaces[0].Types.ToDictionary(o => o.Symbol.Name);
Assert.AreEqual(3, types[nameof(Preconditions)].Methods.Count);
var methods = types[nameof(Preconditions)].Methods.ToDictionary(o => o.Symbol.Name);
Assert.AreEqual(1, methods[readFile].Preconditions.Count);
Assert.AreEqual(0, methods[divideShort].Preconditions.Count);
Assert.AreEqual(1, methods[divide].Preconditions.Count);
foreach (var method in methods.Values)
{
Assert.AreEqual(MethodConversion.ToAsync, method.Conversion);
}
};
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(MethodConversion.Smart);
})
.Callbacks(c => c
.AfterAnalyzation(afterAnalyzationFn)
)
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
}
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 static int Main(string[] args)
{
XmlConfigurator.Configure();
Logger.Info($"AsyncGenerator{Environment.NewLine}");
var cancellationSource = new CancellationTokenSource();
Console.CancelKeyPress += (sender, e) =>
{
Logger.Warn("Canceling operations...");
cancellationSource.Cancel();
};
try
{
EnvironmentHelper.Setup();
var configuration = Configure();
if (configuration == null)
{
Logger.Info("Could not find configuration file:");
Logger.Info($"\t - please make sure that your working directory contains either AsyncGenerator.xml or AsyncGenerator.yml{Environment.NewLine}");
Logger.Info("Working directory:");
Logger.Info($"\t- {Environment.CurrentDirectory}{Environment.NewLine}");
return(1);
}
AsyncCodeGenerator.GenerateAsync(configuration, cancellationSource.Token)
.GetAwaiter()
.GetResult();
return(0);
}
catch (Exception e)
{
Logger.Fatal(e);
return(-1);
}
}
public void TestAfterAnalyzation()
{
var preconditionReturn = GetMethodName(o => o.PreconditionReturn(null));
var preconditionVoid = GetMethodName(o => o.PreconditionVoid(null));
var preconditionToSplit = GetMethodName(o => o.PreconditionToSplit(null));
var syncPrecondition = GetMethodName(o => o.SyncPrecondition(null));
var readFile = GetMethodName(o => o.ReadFile());
var syncReadFile = GetMethodName(o => o.SyncReadFile());
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces[0].Types.Count);
Assert.AreEqual(6, result.Documents[0].Namespaces[0].Types[0].Methods.Count);
var methods = result.Documents[0].Namespaces[0].Types[0].Methods.ToDictionary(o => o.Symbol.Name);
CheckMethodsConversion(methods.Values);
Assert.AreEqual(1, methods[readFile].InvokedBy.Count);
var method = methods[preconditionReturn];
Assert.AreEqual(1, method.Preconditions.Count);
Assert.IsTrue(method.OmitAsync);
Assert.IsFalse(method.WrapInTryCatch);
Assert.IsFalse(method.SplitTail);
var methodReference = method.MethodReferences.First();
Assert.AreEqual(ReferenceConversion.ToAsync, methodReference.GetConversion());
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.LastInvocation);
Assert.AreEqual(methods[readFile], methodReference.ReferenceFunctionData);
method = methods[preconditionVoid];
Assert.AreEqual(1, method.Preconditions.Count);
Assert.IsTrue(method.OmitAsync);
Assert.IsFalse(method.WrapInTryCatch);
Assert.IsFalse(method.SplitTail);
methodReference = method.MethodReferences.First();
Assert.AreEqual(ReferenceConversion.ToAsync, methodReference.GetConversion());
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.LastInvocation);
Assert.IsNull(methodReference.ReferenceFunctionData);
method = methods[preconditionToSplit];
Assert.AreEqual(1, method.Preconditions.Count);
Assert.IsFalse(method.OmitAsync);
Assert.IsFalse(method.WrapInTryCatch);
Assert.IsTrue(method.SplitTail);
methodReference = method.MethodReferences.First();
Assert.AreEqual(ReferenceConversion.ToAsync, methodReference.GetConversion());
Assert.IsTrue(methodReference.AwaitInvocation);
Assert.IsFalse(methodReference.UseAsReturnValue);
Assert.IsFalse(methodReference.LastInvocation);
Assert.IsNull(methodReference.ReferenceFunctionData);
method = methods[syncPrecondition];
Assert.AreEqual(1, method.Preconditions.Count);
Assert.IsTrue(method.OmitAsync);
Assert.IsTrue(method.WrapInTryCatch);
Assert.IsFalse(method.SplitTail);
Assert.AreEqual(0, method.MethodReferences.Count);
};
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(symbol.Name == syncReadFile ? MethodConversion.Ignore : MethodConversion.ToAsync);
})
.Callbacks(c => c
.AfterAnalyzation(afterAnalyzationFn)
)
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
}
public void TestAfterAnalyzation()
{
var simpleReturn = GetMethodName(o => o.SimpleReturn());
var doubleCallReturn = GetMethodName(o => o.DoubleCallReturn());
var syncReturn = GetMethodName(o => o.SyncReturn());
var simpleVoid = GetMethodName(o => o.SimpleVoid);
var doubleCallVoid = GetMethodName(o => o.DoubleCallVoid);
var expressionVoid = GetMethodName(o => o.ExpressionVoid);
var expressionReturn = GetMethodName(o => o.ExpressionReturn());
var readFile = GetMethodName(o => o.ReadFile());
var syncReadFile = GetMethodName(o => o.SyncReadFile());
var write = GetMethodName(() => SimpleFile.Write(null));
var read = GetMethodName(() => SimpleFile.Read());
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces[0].Types.Count);
Assert.AreEqual(9, result.Documents[0].Namespaces[0].Types[0].Methods.Count);
var methods = result.Documents[0].Namespaces[0].Types[0].Methods.ToDictionary(o => o.Symbol.Name);
IInvokeFunctionReferenceAnalyzationResult methodReference;
IMethodAnalyzationResult method;
method = methods[simpleReturn];
Assert.IsTrue(method.OmitAsync);
Assert.IsFalse(method.WrapInTryCatch);
Assert.AreEqual(1, method.MethodReferences.Count);
methodReference = method.MethodReferences[0];
Assert.AreEqual(ReferenceConversion.ToAsync, methodReference.GetConversion());
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.LastInvocation);
method = methods[doubleCallReturn];
Assert.IsFalse(method.OmitAsync);
Assert.IsFalse(method.SplitTail);
Assert.IsFalse(method.WrapInTryCatch);
Assert.AreEqual(2, method.MethodReferences.Count);
var methodReferences = method.MethodReferences.ToLookup(o => o.ReferenceSymbol.Name);
methodReference = methodReferences[write].First();
Assert.AreEqual(ReferenceConversion.ToAsync, methodReference.GetConversion());
Assert.IsTrue(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.LastInvocation);
methodReference = methodReferences[readFile].First();
Assert.AreEqual(ReferenceConversion.ToAsync, methodReference.GetConversion());
Assert.IsTrue(methodReference.AwaitInvocation);
Assert.IsFalse(methodReference.UseAsReturnValue);
Assert.IsFalse(methodReference.LastInvocation);
method = methods[syncReturn];
Assert.AreEqual(MethodConversion.ToAsync, method.Conversion);
Assert.IsTrue(method.OmitAsync);
Assert.IsTrue(method.WrapInTryCatch);
Assert.IsFalse(method.SplitTail);
Assert.AreEqual(1, method.MethodReferences.Count);
methodReference = method.MethodReferences.First();
Assert.AreEqual(ReferenceConversion.Ignore, methodReference.GetConversion());
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.LastInvocation);
method = methods[simpleVoid];
Assert.AreEqual(MethodConversion.ToAsync, method.Conversion);
Assert.IsTrue(method.OmitAsync);
Assert.IsFalse(method.WrapInTryCatch);
Assert.IsFalse(method.SplitTail);
Assert.AreEqual(1, method.MethodReferences.Count);
methodReference = method.MethodReferences.First();
Assert.AreEqual(ReferenceConversion.ToAsync, methodReference.GetConversion());
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.LastInvocation);
method = methods[doubleCallVoid];
Assert.IsTrue(method.OmitAsync);
Assert.IsFalse(method.SplitTail);
Assert.IsTrue(method.WrapInTryCatch);
Assert.AreEqual(2, method.MethodReferences.Count);
methodReferences = method.MethodReferences.ToLookup(o => o.ReferenceSymbol.Name);
methodReference = methodReferences[read].First();
Assert.AreEqual(ReferenceConversion.ToAsync, methodReference.GetConversion());
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.LastInvocation);
methodReference = methodReferences[syncReadFile].First();
Assert.AreEqual(ReferenceConversion.Ignore, methodReference.GetConversion());
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsFalse(methodReference.UseAsReturnValue);
Assert.IsFalse(methodReference.LastInvocation);
method = methods[expressionVoid];
Assert.AreEqual(MethodConversion.ToAsync, method.Conversion);
Assert.IsTrue(method.OmitAsync);
Assert.IsFalse(method.WrapInTryCatch);
Assert.IsFalse(method.SplitTail);
Assert.AreEqual(1, method.MethodReferences.Count);
methodReference = method.MethodReferences.First();
Assert.AreEqual(ReferenceConversion.ToAsync, methodReference.GetConversion());
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.LastInvocation);
method = methods[expressionReturn];
Assert.AreEqual(MethodConversion.ToAsync, method.Conversion);
Assert.IsTrue(method.OmitAsync);
Assert.IsFalse(method.WrapInTryCatch);
Assert.IsFalse(method.SplitTail);
Assert.AreEqual(1, method.MethodReferences.Count);
methodReference = method.MethodReferences.First();
Assert.AreEqual(ReferenceConversion.ToAsync, methodReference.GetConversion());
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.LastInvocation);
};
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(symbol.Name == syncReturn ? MethodConversion.ToAsync : MethodConversion.Smart);
})
.Callbacks(c => c
.AfterAnalyzation(afterAnalyzationFn)
)
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
}
public async Task YamlReadonlyTest(string yamlConfig, Action <IFluentProjectConfiguration> action = null)
{
var configuration = ConfigureByYaml(yamlConfig, null, action).ProjectConfigurations.Single();
var projectData = AsyncCodeGenerator.CreateProjectData(ReadOnlyProjectAndSolutionLazy.Value.Project, configuration);
await AsyncCodeGenerator.GenerateProject(projectData, LoggerFactory, Logger).ConfigureAwait(false);
}
public async Task ReadonlyTest(Action <IFluentProjectConfiguration> action = null)
{
var configuration = Configure(action).ProjectConfigurations.Single();
var projectData = AsyncCodeGenerator.CreateProjectData(ReadOnlyProject.Value, configuration);
await AsyncCodeGenerator.GenerateProject(projectData, LoggerFactory, Logger).ConfigureAwait(false);
}
public async Task XmlReadonlyTest(string fileName, string xmlConfig, Action <IFluentProjectConfiguration> action = null)
{
var configuration = ConfigureByXml(xmlConfig, fileName, action).ProjectConfigurations.Single();
var projectData = AsyncCodeGenerator.CreateProjectData(ReadOnlyProject.Value, configuration);
await AsyncCodeGenerator.GenerateProject(projectData, LoggerFactory, Logger).ConfigureAwait(false);
}
public void TestUseCancellationTokenOverloadAfterAnalyzation()
{
var readFile = GetMethodName(o => o.ReadFile);
var callReadFile = GetMethodName(o => o.CallReadFile);
var callCallReadFile = GetMethodName(o => o.CallCallReadFile);
var read = GetMethodName(() => SimpleFile.Read());
var readAsync = GetMethodName(() => SimpleFile.ReadAsync());
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces[0].Types.Count);
Assert.AreEqual(3, result.Documents[0].Namespaces[0].Types[0].Methods.Count);
var methods = result.Documents[0].Namespaces[0].Types[0].Methods.ToDictionary(o => o.Symbol.Name);
// Check conversions
CheckMethodsConversion(methods.Values);
//Check token
Assert.IsTrue(methods[readFile].CancellationTokenRequired);
Assert.IsTrue(methods[callReadFile].CancellationTokenRequired);
Assert.IsTrue(methods[callCallReadFile].CancellationTokenRequired);
Assert.IsTrue(methods[readFile].OmitAsync);
// Check MethodReferences
Assert.AreEqual(1, methods[readFile].MethodReferences.Count);
var methodReference = methods[readFile].MethodReferences[0];
Assert.AreEqual(SyntaxKind.InvocationExpression, methodReference.ReferenceNode.Kind());
Assert.IsFalse(methodReference.Ignore);
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.CancellationTokenRequired);
Assert.IsNull(methodReference.ReferenceFunctionData);
Assert.AreEqual(read, methodReference.ReferenceSymbol.Name);
Assert.AreEqual(2, methodReference.ReferenceAsyncSymbols.Count);
Assert.AreEqual(readAsync, methodReference.ReferenceAsyncSymbols[0].Name);
Assert.AreEqual(readAsync, methodReference.ReferenceAsyncSymbols[1].Name);
methodReference = methods[callReadFile].MethodReferences[0];
Assert.AreEqual(SyntaxKind.InvocationExpression, methodReference.ReferenceNode.Kind());
Assert.IsFalse(methodReference.Ignore);
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.CancellationTokenRequired);
methodReference = methods[callCallReadFile].MethodReferences[0];
Assert.AreEqual(SyntaxKind.InvocationExpression, methodReference.ReferenceNode.Kind());
Assert.IsFalse(methodReference.Ignore);
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
Assert.IsTrue(methodReference.CancellationTokenRequired);
};
var methodConversions = new Func <IMethodSymbol, MethodConversion>[] {
s => s.Name == readFile ? MethodConversion.ToAsync : MethodConversion.Unknown,
s => s.Name == readFile ? MethodConversion.Smart : MethodConversion.Unknown,
s => s.Name == callCallReadFile ? MethodConversion.ToAsync : MethodConversion.Smart
};
foreach (var methodConversion in methodConversions)
{
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(methodConversion)
.UseCancellationTokenOverload(true)
.Callbacks(c => c.AfterAnalyzation(afterAnalyzationFn))
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
Console.WriteLine("Passed");
}
}
public void TestAfterAnalyzation()
{
var longCastReturn = GetMethodName(o => o.LongCastReturn());
var enumerableCastReturn = GetMethodName(o => o.EnumerableCastReturn());
var noCastReturn = GetMethodName(o => o.NoCastReturn());
var noCastReturnTask = GetMethodName(o => o.NoCastReturnTask());
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces[0].Types.Count);
Assert.AreEqual(6, result.Documents[0].Namespaces[0].Types[0].Methods.Count);
var methods = result.Documents[0].Namespaces[0].Types[0].Methods.ToDictionary(o => o.Symbol.Name);
var awaitRequiredMethods = new[]
{
longCastReturn,
enumerableCastReturn
};
IInvokeFunctionReferenceAnalyzationResult methodReference;
IMethodAnalyzationResult method;
foreach (var awaitRequiredMethod in awaitRequiredMethods)
{
method = methods[awaitRequiredMethod];
Assert.IsFalse(method.OmitAsync);
Assert.AreEqual(1, method.MethodReferences.Count);
methodReference = method.MethodReferences[0];
Assert.IsTrue(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
}
var awaitNotRequiredMethods = new[]
{
noCastReturn,
noCastReturnTask
};
foreach (var awaitNotRequiredMethod in awaitNotRequiredMethods)
{
method = methods[awaitNotRequiredMethod];
Assert.IsTrue(method.OmitAsync);
Assert.AreEqual(1, method.MethodReferences.Count);
methodReference = method.MethodReferences[0];
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.UseAsReturnValue);
}
};
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(MethodConversion.Smart);
})
.Callbacks(c => c
.AfterAnalyzation(afterAnalyzationFn)
)
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
}
public void TestAfterAnalyzation()
{
var notAwaitedActionTask = GetMethodName(o => o.NotAwaitedActionTask);
var notAwaitedFunctionTask = GetMethodName(o => o.NotAwaitedFunctionTask);
var waitActionTask = GetMethodName(o => o.WaitActionTask);
var runSynchronouslyActionTask = GetMethodName(o => o.RunSynchronouslyActionTask);
var waitFunctionTask = GetMethodName(o => o.WaitFunctionTask);
var waitFunctionTaskNoResult = GetMethodName(o => o.WaitFunctionTaskNoResult);
var awaitedActionTask = GetMethodName(o => o.AwaitedActionTask);
var awaitedFunctionTask = GetMethodName(o => o.AwaitedFunctionTask);
var configuratedAwaitedActionTask = GetMethodName(o => o.ConfiguratedAwaitedActionTask);
var configuratedAwaitedFunctionTask = GetMethodName(o => o.ConfiguratedAwaitedFunctionTask);
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces[0].Types.Count);
Assert.AreEqual(10, result.Documents[0].Namespaces[0].Types[0].Methods.Count);
var methods = result.Documents[0].Namespaces[0].Types[0].Methods.ToDictionary(o => o.Symbol.Name);
IInvokeFunctionReferenceAnalyzationResult methodReference;
var awaitableMethods = new[]
{
waitActionTask,
runSynchronouslyActionTask,
waitFunctionTask,
waitFunctionTaskNoResult,
awaitedActionTask,
awaitedFunctionTask,
configuratedAwaitedActionTask,
configuratedAwaitedFunctionTask
};
foreach (var awaitableMethod in awaitableMethods)
{
Assert.AreEqual(1, methods[awaitableMethod].MethodReferences.Count);
methodReference = methods[awaitableMethod].MethodReferences[0];
Assert.IsTrue(methodReference.AwaitInvocation);
Assert.IsTrue(methodReference.SynchronouslyAwaited);
}
var notAwaitableMethods = new[]
{
notAwaitedActionTask,
notAwaitedFunctionTask
};
foreach (var notAwaitableMethod in notAwaitableMethods)
{
Assert.AreEqual(1, methods[notAwaitableMethod].MethodReferences.Count);
methodReference = methods[notAwaitableMethod].MethodReferences[0];
Assert.IsFalse(methodReference.AwaitInvocation);
Assert.IsFalse(methodReference.SynchronouslyAwaited);
}
var configurableAwaitableMethods = new[]
{
configuratedAwaitedActionTask,
configuratedAwaitedFunctionTask,
};
foreach (var configurableAwaitableMethod in configurableAwaitableMethods)
{
methodReference = methods[configurableAwaitableMethod].MethodReferences[0];
Assert.IsNotNull(methodReference.ConfigureAwaitParameter);
}
};
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(MethodConversion.ToAsync);
})
.Callbacks(c => c
.AfterAnalyzation(afterAnalyzationFn)
)
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
}
public void TestAfterAnalyzation()
{
var readFile = GetMethodName(o => o.ReadFile());
var declareAction = GetMethodName(o => o.DeclareAction());
var declareFunction = GetMethodName(o => o.DeclareFunction());
var declareNamedDelegate = GetMethodName(o => o.DeclareNamedDelegate());
var returnDelegate = GetMethodName(o => o.ReturnDelegate());
var argumentAction = GetMethodName(o => o.ArgumentAction);
var generator = new AsyncCodeGenerator();
Action <IProjectAnalyzationResult> afterAnalyzationFn = result =>
{
Assert.AreEqual(1, result.Documents.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces.Count);
Assert.AreEqual(1, result.Documents[0].Namespaces[0].Types.Count);
Assert.AreEqual(TypeConversion.Partial, result.Documents[0].Namespaces[0].Types[0].Conversion);
Assert.AreEqual(6, result.Documents[0].Namespaces[0].Types[0].Methods.Count);
var methods = result.Documents[0].Namespaces[0].Types[0].Methods.ToDictionary(o => o.Symbol.Name);
Assert.AreEqual(5, methods[readFile].InvokedBy.Count);
var readFileMethod = methods[readFile];
var ignoredAnonymousMethods = new[]
{
declareNamedDelegate,
returnDelegate,
declareFunction,
declareAction
};
IMethodAnalyzationResult method;
foreach (var ignoredAnonymousMethod in ignoredAnonymousMethods)
{
method = methods[ignoredAnonymousMethod];
Assert.AreEqual(MethodConversion.Ignore, method.Conversion);
Assert.AreEqual(1, method.AnonymousFunctions.Count);
Assert.AreEqual(MethodConversion.Ignore, method.AnonymousFunctions[0].Conversion);
Assert.AreEqual(1, method.AnonymousFunctions[0].MethodReferences.Count);
Assert.IsTrue(readFileMethod.InvokedBy.Any(o => o == method.AnonymousFunctions[0]));
}
method = methods[argumentAction];
Assert.AreEqual(MethodConversion.ToAsync, method.Conversion);
Assert.AreEqual(1, method.AnonymousFunctions.Count);
Assert.AreEqual(MethodConversion.ToAsync, method.AnonymousFunctions[0].Conversion);
Assert.AreEqual(1, method.AnonymousFunctions[0].MethodReferences.Count);
Assert.IsTrue(readFileMethod.InvokedBy.Any(o => o == method.AnonymousFunctions[0]));
};
var config = Configure(p => p
.ConfigureAnalyzation(a => a
.MethodConversion(symbol =>
{
return(symbol.Name == readFile ? MethodConversion.ToAsync : MethodConversion.Smart);
})
.Callbacks(c => c
.AfterAnalyzation(afterAnalyzationFn)
)
)
);
Assert.DoesNotThrowAsync(async() => await generator.GenerateAsync(config));
}
