public void ShouldHaveWarningWhenFileIsEmptyOrWhitespace(string fileContent) { // Arrange var fileName = "test.txt"; var additionalText = new StringAdditionalText(fileName, fileContent); // Act ExecuteGenerator(new[] { additionalText }, out Compilation compilation, out GeneratorDriverRunResult runResult); // Assert runResult.Diagnostics.Should().Contain(d => d.Descriptor == DiagnosticsDescriptors.EmptyFile && d.Severity == DiagnosticSeverity.Warning); }
public void ShouldHaveErrorWhenWordContainsNonAlphabetCharacters() { // Arrange var fileName = "test.txt"; var words = new[] { "foo", "b@r" }; var additionalText = new StringAdditionalText(fileName, string.Join(Environment.NewLine, words)); // Act ExecuteGenerator(new[] { additionalText }, out Compilation compilation, out GeneratorDriverRunResult runResult); // Assert runResult.Diagnostics.Should().Contain(d => d.Descriptor == DiagnosticsDescriptors.InvalidWord && d.Severity == DiagnosticSeverity.Error); }
public void ShouldGenerateCorrectOutput() { // Arrange var fileName = "test.txt"; var expectedPropertyName = "Test"; var expectedWords = new[] { "foo", "bar" }; var expectedTypeName = "FriendlyWordsDotNet.FriendlyWords"; var additionalText = new StringAdditionalText(fileName, string.Join(Environment.NewLine, expectedWords)); ExecuteGenerator(new[] { additionalText }, out Compilation outputCompilation, out GeneratorDriverRunResult runResult); SemanticModel model = outputCompilation.GetSemanticModel(runResult.GeneratedTrees[0]); TestContext.WriteLine("Generated code:"); TestContext.Write(runResult.GeneratedTrees[0]); using (new AssertionScope("Generator Output")) { runResult.Diagnostics.Should().BeEmpty("generator should not generate any diagnostic errors from a valid file"); runResult.GeneratedTrees.Should().HaveCount(1, "generator should only generate a single syntax tree"); outputCompilation.GetDiagnostics().Should().BeEmpty("output compilation should be valid"); } // Class Assertions INamedTypeSymbol? @class = outputCompilation.GetTypeByMetadataName(expectedTypeName); @class.Should().NotBeNull("generator should create the type {0}", expectedTypeName); using (new AssertionScope()) { @class !.TypeKind.Should().Be(TypeKind.Class, "type {0} should be a class", expectedTypeName); @class.DeclaredAccessibility.Should().Be(Accessibility.Public, "type {0} should be publicly accessible", expectedTypeName); @class.IsStatic.Should().BeFalse("type {0} should not be static", expectedTypeName); @class.IsSealed.Should().BeTrue("type {0} should be sealed", expectedTypeName); var classDeclaration = (ClassDeclarationSyntax)@class.DeclaringSyntaxReferences[0].GetSyntax(); classDeclaration.Modifiers.Should().Contain(t => t.IsKind(SyntaxKind.PartialKeyword), "declaration of type {0} should have the partial modifier", expectedTypeName); } // Property Assertions IPropertySymbol?property = @class.GetProperty(expectedPropertyName); property.Should().NotBeNull("property {0} should be generated", expectedPropertyName); using (new AssertionScope()) { property !.IsStatic.Should().BeTrue("property {0} should be static", expectedPropertyName); property.IsReadOnly.Should().BeTrue("property {0} should only have a getter", expectedPropertyName); property.DeclaredAccessibility.Should().Be(Accessibility.Public, "property {0} should be publicly accessible", expectedPropertyName); ITypeSymbol expectedPropertyType = outputCompilation.GetSymbolForType <IReadOnlyCollection <string> >(); property.Type.Should().Be(expectedPropertyType, "property {0} should be of type {1}", expectedPropertyName, expectedPropertyType); property.DeclaringSyntaxReferences.Should().HaveCount(1, "property {0} should only be declared a single time", expectedPropertyName); } // Property Initializer Assertions using (new AssertionScope()) { var propertyNode = (PropertyDeclarationSyntax)property.DeclaringSyntaxReferences[0].GetSyntax(); propertyNode.Initializer.Should().NotBeNull("property {0} should have an initializer", expectedPropertyName); propertyNode.Initializer !.Value.IsKind(SyntaxKind.ObjectCreationExpression).Should().BeTrue("initializer for property {0} should be an object creation expression", expectedPropertyName); var objectCreation = (ObjectCreationExpressionSyntax)propertyNode.Initializer.Value; ISymbol objectTypeSymbol = model.GetSymbolInfo(objectCreation.Type).Symbol !; ITypeSymbol expectedInitializerObjectType = outputCompilation.GetSymbolForType <ReadOnlyCollection <string> >(); objectTypeSymbol.Should().Be(expectedInitializerObjectType, "initializer for property {0} should create an instance of {1}", expectedPropertyName, expectedInitializerObjectType); SeparatedSyntaxList <ArgumentSyntax> args = objectCreation.ArgumentList !.Arguments; args.Should().HaveCount(1); ArgumentSyntax argument = args.First(); var arrayCreationExpression = (ImplicitArrayCreationExpressionSyntax)argument.Expression; arrayCreationExpression.Initializer.Expressions.Should().AllBeOfType <LiteralExpressionSyntax>().And.OnlyContain(l => l.IsKind(SyntaxKind.StringLiteralExpression), "initialized array should only contain strings"); arrayCreationExpression.Initializer.Expressions.OfType <LiteralExpressionSyntax>().Select(e => e.Token.ValueText).Should().BeEquivalentTo(expectedWords, "initialized array should contain all the words from the AdditionalText"); } }