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)); }