{"id":1165,"date":"2017-06-19T20:21:14","date_gmt":"2017-06-19T20:21:14","guid":{"rendered":"http:\/\/tpodolak.com\/blog\/?p=1165"},"modified":"2017-06-19T20:21:14","modified_gmt":"2017-06-19T20:21:14","slug":"xunit-memberdataattribute-generic-type-inheritance","status":"publish","type":"post","link":"https:\/\/tpodolak.com\/blog\/2017\/06\/19\/xunit-memberdataattribute-generic-type-inheritance\/","title":{"rendered":"XUnit – MemberDataAttribute and generic type inheritance"},"content":{"rendered":"

1. Introduction.<\/h3>\n

When I was writing Cake.Intellisense<\/a> I was playing a lot with Roslyn<\/i> syntax rewriters. The one thing which was pretty important for me at this time was a reliable set of tests which can quickly show if rewritten code is valid C#<\/i> code and if it matches my expectations. As I don\u2019t like to repeat my code I wanted to have a base test class which can be provided with different test cases from inherited classes. The initial implementation looked as follows<\/p>\n

\r\npublic abstract class CSharpSyntaxRewriterTest where T : CSharpSyntaxRewriter\r\n{\r\n    public static IEnumerable TestCases { get; set; }\r\n    protected T Subject { get; }\r\n\r\n    private readonly NSubstituteAutoMocker _autoMock;\r\n    \r\n    protected CSharpSyntaxRewriterTest()\r\n    {\r\n        _autoMock = new NSubstituteAutoMocker();\r\n        Subject = _autoMock.ClassUnderTest;\r\n    }\r\n\r\n    [Theory]\r\n    [MemberData(nameof(TestCases))]\r\n    public void Verify(SyntaxRewriterTestCase testCase)\r\n    {\r\n        var inputTree = SyntaxFactory.ParseSyntaxTree(testCase.Input);\r\n        var result = Subject.Visit(inputTree.GetRoot());\r\n\r\n        inputTree.GetDiagnostics().Should().BeEmpty();\r\n        result.GetDiagnostics().Should().BeEmpty();\r\n        result.ToFullString().Should().Be(testCase.ExpectedResult);\r\n    }\r\n}\r\n<\/pre>\n
\r\npublic class InternalToPublicClassModifierSyntaxRewriter : CSharpSyntaxRewriter\r\n{ \r\n    public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)\r\n    {\r\n        var internalModifierIndex = node.Modifiers.IndexOf(SyntaxKind.InternalKeyword);\r\n            \r\n        if (internalModifierIndex > -1)\r\n        {\r\n            var tokenInList = node.Modifiers[internalModifierIndex];\r\n            var updatedModifiers = node.Modifiers.Replace(tokenInList,\r\n                   SyntaxFactory.Token(SyntaxKind.PublicKeyword).WithLeadingTrivia(tokenInList.LeadingTrivia)\r\n                        .WithTrailingTrivia(tokenInList.TrailingTrivia));\r\n\r\n            node = node.WithModifiers(updatedModifiers);\r\n         }\r\n\r\n         return base.VisitClassDeclaration(node);\r\n    }\r\n}\r\n<\/pre>\n
The rewriter shown above is a very simple piece of code which replaces internal class modifier with a public one. Writing the tests for that class was supposed to be very easy, I just had to provide test cases with input code and expected result.<\/p>\n
\r\npublic class InternalToPublicClassModifierSyntaxRewriterTests\r\n        : CSharpSyntaxRewriterTest\r\n{\r\n    static InternalToPublicClassModifierSyntaxRewriterTests()\r\n    {\r\n        TestCases = new[]\r\n        {\r\n            new[] { ReplacesInternalModifierWithPublic() },\r\n            new[] { LeavesModifiersIntactWhenClassModifierPublic() },\r\n            new[] { LeavesModifiersIntactWhenClassModifierProtected() }\r\n        };\r\n    }\r\n\r\n    private static SyntaxRewriterTestCase ReplacesInternalModifierWithPublic()\r\n    {\r\n        return new SyntaxRewriterTestCase(nameof(ReplacesInternalModifierWithPublic), \r\n                \"internal class Foo { }\", \"public class Foo { }\");\r\n    }\r\n\r\n    private static SyntaxRewriterTestCase LeavesModifiersIntactWhenClassModifierPublic()\r\n    {\r\n        return new SyntaxRewriterTestCase(nameof(LeavesModifiersIntactWhenClassModifierPublic),\r\n                \"public class Foo { }\", \"public class Foo { }\");\r\n    }\r\n\r\n    private static SyntaxRewriterTestCase LeavesModifiersIntactWhenClassModifierProtected()\r\n    {\r\n        return new SyntaxRewriterTestCase(nameof(LeavesModifiersIntactWhenClassModifierProtected),\r\n                \"protected class Foo { }\", \"protected class Foo { }\");\r\n    }\r\n}\r\n<\/pre>\n
Unfortunately running the tests resulted in InvalidOperationException<\/i> being thrown from XUnit<\/i>
\n\"\"<\/a>
\nIf you look closely at the message you will notice that the TestCases<\/i> field used for providing data was not initialized, which means that the static constructor of class InternalToPublicClassModifierSyntaxRewriterTests<\/i> was not run. That was pretty surprising for me that is why I wanted to investigated the issue a bit more. <\/p>\n
2. Investigation. <\/h3>\n
I started from going back to the basics. As we probably all know, the static constructor is triggered when one of the following events occur:<\/p>\n
As you can see I have a generic base test class which holds test cases in a static field TestCases<\/i>. The field is static as it is required by XUnit<\/i>, this solution is perfectly valid because a\u00a0static\u00a0field is shared across all instances\u00a0of the same type<\/a>. Having a base test class ready I wanted to write a set of unit tests for following syntax rewriter<\/p>\n