public void CalculateChangeHandlesAllPossibleValues(StructModifiers oldValue, StructModifiers newValue)
        {
            var sut = new StructModifiersChangeTable();

            Action action = () => sut.CalculateChange(oldValue, newValue);

            action.Should().NotThrow();
        }
        public void CalculateChangeReturnsExpectedValueForMemberDefinition(StructModifiers oldValue,
                                                                           StructModifiers newValue,
                                                                           SemVerChangeType expected)
        {
            var sut = new StructModifiersChangeTable();

            var actual = sut.CalculateChange(oldValue, newValue);

            actual.Should().Be(expected);
        }
        public async Task ModifiersReturnsExpectedValue(string modifiers, StructModifiers expected)
        {
            var code = EmptyStruct.Replace("public struct MyStruct", "public " + modifiers + " struct MyStruct");

            var node = await TestNode.FindNode <StructDeclarationSyntax>(code)
                       .ConfigureAwait(false);

            var sut = new StructDefinition(node);

            sut.Modifiers.Should().Be(expected);
        }
        public async Task MergePartialTypeMergesModifiers(string firstModifiers, string secondModifiers,
                                                          StructModifiers expected)
        {
            var firstCode  = StructWithFields.Replace("struct", firstModifiers + " partial struct");
            var secondCode = StructWithFields
                             .Replace("struct", secondModifiers + " partial struct")
                             .Replace("First", "Third")
                             .Replace("Second", "Fourth");

            var firstNode = await TestNode.FindNode <StructDeclarationSyntax>(firstCode)
                            .ConfigureAwait(false);

            var secondNode = await TestNode.FindNode <StructDeclarationSyntax>(secondCode)
                             .ConfigureAwait(false);

            var firstDefinition  = new StructDefinition(firstNode);
            var secondDefinition = new StructDefinition(secondNode);

            firstDefinition.MergePartialType(secondDefinition);

            firstDefinition.Modifiers.Should().Be(expected);
        }