public void TryEditStartupForNewContext_Adds_Context_Registration_To_ConfigureServices(string beforeStartupResource, string afterStartupResource, string dbContextResource) { string resourcePrefix = "compiler/resources/"; var beforeStartupText = ResourceUtilities.GetEmbeddedResourceFileContent(resourcePrefix + beforeStartupResource); var afterStartupText = ResourceUtilities.GetEmbeddedResourceFileContent(resourcePrefix + afterStartupResource); var dbContextText = ResourceUtilities.GetEmbeddedResourceFileContent(resourcePrefix + dbContextResource); var startupTree = CSharpSyntaxTree.ParseText(beforeStartupText); var contextTree = CSharpSyntaxTree.ParseText(dbContextText); var efReference = MetadataReference.CreateFromFile(typeof(DbContext).Assembly.Location); var compilation = CSharpCompilation.Create("DoesNotMatter", new[] { startupTree, contextTree }, new[] { efReference }); DbContextEditorServices testObj = new DbContextEditorServices( new Mock <ILibraryManager>().Object, new Mock <IApplicationEnvironment>().Object, new Mock <IFilesLocator>().Object, new Mock <ITemplating>().Object); var types = RoslynUtilities.GetDirectTypesInCompilation(compilation); var startupType = ModelType.FromITypeSymbol(types.Where(ts => ts.Name == "Startup").First()); var contextType = ModelType.FromITypeSymbol(types.Where(ts => ts.Name == "MyContext").First()); var result = testObj.EditStartupForNewContext(startupType, "MyContext", "ContextNamespace", "MyContext-NewGuid"); Assert.True(result.Edited); Assert.Equal(afterStartupText, result.NewTree.GetText().ToString()); }
private void ValidateCommandLine(IdentityGeneratorCommandLineModel model) { var errorStrings = new List <string>(); if (!string.IsNullOrEmpty(model.UserClass) && !RoslynUtilities.IsValidNamespace(model.UserClass)) { errorStrings.Add(string.Format(MessageStrings.InvalidUserClassName, model.UserClass)); } if (!string.IsNullOrEmpty(model.DbContext) && !RoslynUtilities.IsValidNamespace(model.DbContext)) { errorStrings.Add(string.Format(MessageStrings.InvalidDbContextClassName, model.DbContext)); } if (!string.IsNullOrEmpty(model.RootNamespace) && !RoslynUtilities.IsValidNamespace(model.RootNamespace)) { errorStrings.Add(string.Format(MessageStrings.InvalidNamespaceName, model.RootNamespace)); } if (!string.IsNullOrEmpty(model.Layout) && model.GenerateLayout) { errorStrings.Add(string.Format(MessageStrings.InvalidOptionCombination, "--layout", "--generateLayout")); } if (!string.IsNullOrEmpty(model.BootstrapVersion) && !IdentityGenerator.ValidBootstrapVersions.Contains(model.BootstrapVersion)) { errorStrings.Add(string.Format(MessageStrings.InvalidBootstrapVersionForScaffolding, model.BootstrapVersion, string.Join(", ", IdentityGenerator.ValidBootstrapVersions))); } if (errorStrings.Any()) { throw new ArgumentException(string.Join(Environment.NewLine, errorStrings)); } }
public async void SubjectBuffersConnected(IWpfTextView textView, ConnectionReason reason, Collection <ITextBuffer> subjectBuffers) { if (RoslynUtilities.IsRoslynInstalled(ServiceProvider) || !LanguageUtilities.IsRunning()) { return; } if (!subjectBuffers.Any(b => b.ContentType.IsOfType("CSharp"))) { return; } // VS2010 only creates TextViewAdapters later; wait for it to exist. await Dispatcher.Yield(); var textViewAdapter = EditorAdaptersFactoryService.GetViewAdapter(textView); if (textViewAdapter == null) { return; } ITextDocument document; if (!TextDocumentFactoryService.TryGetTextDocument(textView.TextDataModel.DocumentBuffer, out document)) { return; } textView.Properties.GetOrCreateSingletonProperty(() => new GoToDefinitionInterceptor(ReferenceProviders, ServiceProvider, textViewAdapter, textView, document)); }
public async Task CSharpMetadataTest() { // Hop on to the UI thread so the language service APIs work await Application.Current.Dispatcher.NextFrame(DispatcherPriority.ApplicationIdle); // Use a type that is not in the public reference source textView.Caret.MoveTo(textView.FindSpan("System.IO.Log.LogStore").End); GetCurrentNativeTextView().Execute(VSConstants.VSStd97CmdID.GotoDefn); var metadataTextView = GetCurentTextView(); var docService = componentModel.GetService <ITextDocumentFactoryService>(); ITextDocument document; Assert.IsTrue(docService.TryGetTextDocument(metadataTextView.TextDataModel.DocumentBuffer, out document)); ISymbolResolver resolver = null; if (RoslynUtilities.IsRoslynInstalled(VsIdeTestHostContext.ServiceProvider)) { resolver = new RoslynSymbolResolver(); } else if (DTE.Version == "12.0") { resolver = new CSharp12Resolver(); } if (resolver == null) { var symbol = resolver.GetSymbolAt(document.FilePath, metadataTextView.FindSpan("public LogStore(SafeFileHandle").End); Assert.IsFalse(symbol.HasLocalSource); Assert.AreEqual("mscorlib", symbol.AssemblyName); Assert.AreEqual("T:Microsoft.Win32.SafeHandles.SafeFileHandle", symbol.IndexId); } }
public async Task GeneratesEnableModuleAttributesForAllModules() { StringBuilder builder = new(); foreach (DurianModule module in ModuleIdentity.GetAllModules().AsEnums()) { builder .Append("[assembly: Durian.Generator.EnableModule(Durian.Info.") .Append(nameof(DurianModule)) .Append('.') .Append(module.ToString()) .AppendLine(")]"); } CSharpSyntaxTree expected = (CSharpSyntaxTree)CSharpSyntaxTree.ParseText(builder.ToString()); CSharpCompilation compilation = RoslynUtilities.CreateBaseCompilation(); DisabledModuleAnalyzer analyzer = new(); await analyzer.RunAnalyzer(compilation); SingletonGeneratorTestResult result = GeneratorTest.RunGenerator("", analyzer); Assert.True(result.IsGenerated); Assert.NotNull(result.SyntaxTree); Assert.True(result.SyntaxTree !.IsEquivalentTo(expected)); }
private static MemberDeclarationSyntax CreateValidDeclaration() { CSharpSyntaxTree tree = (CSharpSyntaxTree)CSharpSyntaxTree.ParseText("class Test { }"); MemberDeclarationSyntax decl = RoslynUtilities.ParseNode <ClassDeclarationSyntax>(tree) !; return(decl); }
public void AddModelToContext_Adds_Model_From_Same_Project_To_Context(string beforeContextResource, string modelResource, string afterContextResource) { string resourcePrefix = "compiler/resources/"; var beforeDbContextText = ResourceUtilities.GetEmbeddedResourceFileContent(resourcePrefix + beforeContextResource); var modelText = ResourceUtilities.GetEmbeddedResourceFileContent(resourcePrefix + modelResource); var afterDbContextText = ResourceUtilities.GetEmbeddedResourceFileContent(resourcePrefix + afterContextResource); var contextTree = CSharpSyntaxTree.ParseText(beforeDbContextText); var modelTree = CSharpSyntaxTree.ParseText(modelText); var efReference = MetadataReference.CreateFromFile(typeof(DbContext).Assembly.Location); var compilation = CSharpCompilation.Create("DoesNotMatter", new[] { contextTree, modelTree }, new[] { efReference }); DbContextEditorServices testObj = new DbContextEditorServices( new Mock <ILibraryManager>().Object, new Mock <IApplicationEnvironment>().Object, new Mock <IFilesLocator>().Object, new Mock <ITemplating>().Object); var types = RoslynUtilities.GetDirectTypesInCompilation(compilation); var modelType = ModelType.FromITypeSymbol(types.Where(ts => ts.Name == "MyModel").First()); var contextType = ModelType.FromITypeSymbol(types.Where(ts => ts.Name == "MyContext").First()); var result = testObj.AddModelToContext(contextType, modelType); Assert.True(result.Edited); Assert.Equal(afterDbContextText, result.NewTree.GetText().ToString()); }
public async Task Succcess_When_ReferencesDurianCore() { CSharpCompilation compilation = RoslynUtilities.CreateBaseCompilation(); DependencyAnalyzer analyzer = new(); ImmutableArray <Diagnostic> diagnostics = await analyzer.RunAnalyzer(compilation); Assert.Empty(diagnostics); }
public async Task ModulesAreEnabledByDefault() { CSharpCompilation compilation = RoslynUtilities.CreateBaseCompilation(); DisabledModuleAnalyzer analyzer = new(); await analyzer.RunAnalyzer(compilation); Assert.True(ModuleIdentity.GetAllModules().AsEnums().All(module => DisabledModuleAnalyzer.IsEnabled(module))); }
public async Task CSharpRoslynResolverTest() { if (!RoslynUtilities.IsRoslynInstalled(VsIdeTestHostContext.ServiceProvider)) { Assert.Inconclusive("Roslyn is not installed"); } await TestCSharpResolver(new RoslynSymbolResolver()); }
public async Task CSharp10ResolverTest() { if (RoslynUtilities.IsRoslynInstalled(VsIdeTestHostContext.ServiceProvider)) { Assert.Inconclusive("Cannot test native language services with Roslyn installed?"); } await TestCSharpResolver(new CSharp10Resolver(DTE)); }
public async Task DisablesModule_When_HasDisableModuleAttribute() { string input = "[assembly: Durian.DisableModule(Durian.Info.DurianModule.DefaultParam)]"; CSharpCompilation compilation = RoslynUtilities.CreateBaseCompilation(); compilation = compilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText(input)); DisabledModuleAnalyzer analyzer = new(); await analyzer.RunAnalyzer(compilation); Assert.False(DisabledModuleAnalyzer.IsEnabled(DurianModule.DefaultParam)); }
protected void ValidateNameSpaceName(CommandLineGeneratorModel generatorModel) { if (!string.IsNullOrEmpty(generatorModel.ControllerNamespace) && !RoslynUtilities.IsValidNamespace(generatorModel.ControllerNamespace)) { throw new InvalidOperationException(string.Format( CultureInfo.CurrentCulture, MessageStrings.InvalidNamespaceName, generatorModel.ControllerNamespace)); } }
private string GetDefaultDbContextName() { var defaultDbContextName = $"{_applicationInfo.ApplicationName}IdentityDbContext"; if (!RoslynUtilities.IsValidIdentifier(defaultDbContextName)) { defaultDbContextName = "IdentityDataContext"; } return(defaultDbContextName); }
public async Task CSharp12ResolverTest() { if (DTE.Version != "12.0") { Assert.Inconclusive("CSharp12Resolver only works in VS 2013"); } if (RoslynUtilities.IsRoslynInstalled(VsIdeTestHostContext.ServiceProvider)) { Assert.Inconclusive("Cannot test native language services with Roslyn installed?"); } await TestCSharpResolver(new CSharp12Resolver()); }
public async Task Error_When_ReferencesMainDurianPackageAndAnyDurianAnalyzerPackage() { CSharpCompilation compilation = RoslynUtilities.CreateBaseCompilation(); string dir = Path.GetDirectoryName(typeof(DependencyTests).Assembly.Location) !; string mainPath = Path.Combine(dir, "Durian.dll"); string analyzerPath = Path.Combine(dir, "Durian.Core.Analyzer.dll"); compilation = compilation.AddReferences(MetadataReference.CreateFromFile(mainPath), MetadataReference.CreateFromFile(analyzerPath)); DependencyAnalyzer analyzer = new(); Assert.True(await analyzer.ProducesDiagnostic(compilation, DurianDiagnostics.DUR0007_DoNotReferencePackageIfManagerIsPresent)); }
public async Task Success_When_ReferencesMainPackage() { CSharpCompilation compilation = RoslynUtilities.CreateBaseCompilation(); string dir = Path.GetDirectoryName(typeof(DependencyTests).Assembly.Location) !; string mainPath = Path.Combine(dir, "Durian.dll"); compilation = compilation.AddReferences(MetadataReference.CreateFromFile(mainPath)); DependencyAnalyzer analyzer = new(); ImmutableArray <Diagnostic> diagnostics = await analyzer.RunAnalyzer(compilation); Assert.Empty(diagnostics); }
public async Task Warning_When_HasMultipleAnalyzerPackages_And_NoManager() { CSharpCompilation compilation = RoslynUtilities.CreateBaseCompilation(); string dir = Path.GetDirectoryName(typeof(DependencyTests).Assembly.Location) !; compilation = compilation.AddReferences( MetadataReference.CreateFromFile(Path.Combine(dir, "Durian.Core.Analyzer.dll")), MetadataReference.CreateFromFile(Path.Combine(dir, "Durian.InterfaceTargets.dll")) ); DependencyAnalyzer analyzer = new(); Assert.True(await analyzer.ProducesDiagnostic(compilation, DurianDiagnostics.DUR0008_MultipleAnalyzers)); }
public static void PrepareSolution(TestContext context) { DTE.Solution.Open(Path.Combine(SolutionDir, "TestBed.sln")); componentModel = (IComponentModel)VsIdeTestHostContext.ServiceProvider.GetService(typeof(SComponentModel)); fileName = Path.GetFullPath(Path.Combine(SolutionDir, "Basic", "File.vb")); DTE.ItemOperations.OpenFile(fileName).Activate(); textView = GetCurentTextView(); isRoslyn = RoslynUtilities.IsRoslynInstalled(VsIdeTestHostContext.ServiceProvider); if (isRoslyn) { resolver = new RoslynSymbolResolver(); } else { resolver = new VBResolver(); } }
private void ValidateCommandLine(IdentityGeneratorCommandLineModel model) { var errorStrings = new List <string>();; if (!string.IsNullOrEmpty(model.UserClass) && !RoslynUtilities.IsValidIdentifier(model.UserClass)) { errorStrings.Add(string.Format(MessageStrings.InvalidUserClassName, model.UserClass));; } if (!string.IsNullOrEmpty(model.DbContext) && !RoslynUtilities.IsValidNamespace(model.DbContext)) { errorStrings.Add(string.Format(MessageStrings.InvalidDbContextClassName, model.DbContext));; } if (!string.IsNullOrEmpty(model.RootNamespace) && !RoslynUtilities.IsValidNamespace(model.RootNamespace)) { errorStrings.Add(string.Format(MessageStrings.InvalidNamespaceName, model.RootNamespace)); } if (errorStrings.Any()) { throw new ArgumentException(string.Join(Environment.NewLine, errorStrings)); } }
public void AddAccessor(ButlerAccessorType accessorType, ButlerAccessibility accessibility) { if (accessorType == ButlerAccessorType.Set && !_definedAccessors.Contains(ButlerAccessorType.Get)) { throw new Exception("Cannot define a set accessor without a get accessor."); } AccessorDeclarationSyntax accessor = SyntaxFactory.AccessorDeclaration(RoslynUtilities.FromAccessorType(accessorType)); accessor = accessor.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); if (accessibility > _accessibility) { throw new Exception($"The accessibility modifier of the {accessorType.ToString ()} accessor must be more restrictive than the property"); } if (accessibility != _accessibility) { accessor = accessor.AddModifiers(SyntaxFactory.Token(RoslynUtilities.FromAccessibility(accessibility))); } Info = Info.AddAccessorListAccessors(accessor); _definedAccessors.Add(accessorType); }
public async Task Error_When_IsVisualBasic() { VisualBasicCompilation compilation = VisualBasicCompilation.Create(RoslynUtilities.DefaultCompilationName, null, RoslynUtilities.GetBaseReferences()); IsCSharpCompilationAnalyzer analyzer = new(); Assert.True(await analyzer.ProducesDiagnostic(compilation, DurianDiagnostics.DUR0004_DurianModulesAreValidOnlyInCSharp)); }
public async Task Success_When_IsCSharp() { CSharpCompilation compilation = CSharpCompilation.Create(RoslynUtilities.DefaultCompilationName, null, RoslynUtilities.GetBaseReferences()); IsCSharpCompilationAnalyzer analyzer = new(); ImmutableArray <Diagnostic> diagnostics = await analyzer.RunAnalyzer(compilation); Assert.Empty(diagnostics); }
/// <summary> /// Initializes a new instance of the <see cref="CompilationFixture"/> class. /// </summary> public CompilationFixture() { Compilation = RoslynUtilities.CreateBaseCompilation(); }
public void HasErrorsReturnsFalseByDefault() { Data.CompilationData data = new(RoslynUtilities.CreateBaseCompilation()); Assert.False(data.HasErrors); }
public void CompilationIsNotNullAfterConstructor() { Data.CompilationData data = new(RoslynUtilities.CreateBaseCompilation()); Assert.True(data.Compilation is not null); }
public void TestCreateValidNameSpace(string identifier, bool expectedValue) { Assert.Equal(expectedValue, RoslynUtilities.IsValidNamespace(identifier)); }
public void TestCreateEscapedIdentifier(string identifier, string expectedValue) { Assert.Equal(expectedValue, RoslynUtilities.CreateEscapedIdentifier(identifier)); }
public void SetAccessibility(ButlerAccessibility accessibility) { _accessibility = accessibility; Info = Info.AddModifiers(SyntaxFactory.Token(RoslynUtilities.FromAccessibility(accessibility))); }