Пример #1
0
        public void GetPropertyAccess_ShouldReturnCorrectAccess_WhenPropertyHasAccessor(string expected,
                                                                                        TypeDefinition definition)
        {
            var sut = GetProperties(definition).First();

            Check.That(DefinitionFormatter.GetPropertyAccess(sut)).IsEqualIgnoringCase(expected);
        }
 public void GetEvents_ShouldReturnEventsByVisiblity_WhenDefinitionHasSome(int expected, TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetEvents(definition)).HasSize(expected);
 }
 public void GetPropertyAccess_ShouldReturnReadOnly_WhenPropertyHasOnlyGetAccessor(PropertyDefinition definition)
 {
     Check.That(DefinitionFormatter.GetPropertyAccess(definition)).IsEqualTo("Read-Only");
 }
 public void GetPropertyAccess_ShouldThrow_WhenDefinitionIsNull()
 {
     Check.ThatCode(() => DefinitionFormatter.GetPropertyAccess(null)).Throws <ArgumentNullException>();
 }
 public void GetModifiers_ShouldReturnEmpty_WhenTypeHasNoModifiers(TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetModifiers(definition)).IsEmpty();
 }
        public void GetFields_ShouldReturnExactFieldsCount_WhenTypeHasSome(int expected, TypeDefinition definition)
        {
            var actual = DefinitionFormatter.GetFields(definition).Aggregate(0, (acc, c) => acc + c.Count());

            Check.That(actual).IsEqualTo(expected);
        }
Пример #7
0
 public void GetAccessModifiers_ShouldReturnDefaultModifier_WhenHasNoAccessModifiers(string expected, TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetAccessModifiers(definition)).IsEqualTo(expected);
 }
 public void GetNameWithParameters_ShouldThrow_WhenDefinitionIsNull()
 {
     Check.ThatCode(() => DefinitionFormatter.GetNameWithParameters(null)).Throws <ArgumentNullException>();
 }
        public void GetMethods_ShouldReturnExpectedGroupKey(string[] expected, TypeDefinition definition)
        {
            var actual = DefinitionFormatter.GetMethods(definition).Select(c => c.Key);

            Check.That(actual).Contains(expected);
        }
 public void GetProperties_ShouldReturnNoProperties_WhenTypeCannotHaveProperties(TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetProperties(definition)).IsEmpty();
 }
Пример #11
0
        /// <summary>
        /// Create the template output
        /// </summary>
        public override string TransformText()
        {
            #line 9 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
            var definition = (TypeDefinition)Session["Content"];

            #line default
            #line hidden
            this.Write("### **");

            #line 10 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
            this.Write(this.ToStringHelper.ToStringWithCulture(MarkdownHelper.EscapeString(DefinitionFormatter.GetNameWithParameters(definition.Identity))));

            #line default
            #line hidden
            this.Write("** : ");

            #line 10 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
            this.Write(this.ToStringHelper.ToStringWithCulture(DefinitionFormatter.GetAccessModifiers(definition)));

            #line default
            #line hidden
            this.Write(" ");

            #line 10 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
            this.Write(this.ToStringHelper.ToStringWithCulture(DefinitionFormatter.GetKind(definition)));

            #line default
            #line hidden
            this.Write("\r\n");

            #line 11 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
            this.Write(this.ToStringHelper.ToStringWithCulture(DefinitionFormatter.GetNamespace(definition)));

            #line default
            #line hidden
            this.Write("\r\n***\r\n");

            #line 13 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"

            var modifiers = DefinitionFormatter.GetModifiers(definition);
            if (!string.IsNullOrWhiteSpace(modifiers))
            {
            #line default
            #line hidden
                this.Write("**Modifiers**: ");

            #line 18 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                this.Write(this.ToStringHelper.ToStringWithCulture(modifiers));

            #line default
            #line hidden
                this.Write("\r\n");

            #line 19 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
            }

            var parents = DefinitionFormatter.GetParents(definition);
            if (!string.IsNullOrWhiteSpace(parents))
            {
            #line default
            #line hidden
                this.Write("\r\n**Implements**: ");

            #line 27 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                this.Write(this.ToStringHelper.ToStringWithCulture(MarkdownHelper.EscapeString(parents)));

            #line default
            #line hidden
                this.Write("\r\n");

            #line 28 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
            }

            var returnType = DefinitionFormatter.GetReturnType(definition);
            if (returnType.HasValue)
            {
            #line default
            #line hidden
                this.Write("\r\n**Returns**: ");

            #line 36 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                this.Write(this.ToStringHelper.ToStringWithCulture(MarkdownHelper.EscapeString(returnType.ValueOr(string.Empty))));

            #line default
            #line hidden
                this.Write("\r\n");

            #line 37 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
            }

/****** Display type fields ******/
            var fields = DefinitionFormatter.GetFields(definition);
            if (fields.Any())
            {
            #line default
            #line hidden
                this.Write("\r\n## **Fields**\r\n");

            #line 47 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"

                foreach (var group in fields)
                {
            #line default
            #line hidden
                    this.Write("### **");

            #line 51 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    this.Write(this.ToStringHelper.ToStringWithCulture(CurrentCulture.TextInfo.ToTitleCase(group.Key)));

            #line default
            #line hidden
                    this.Write("**\r\n| Name  | Access |\r\n|---|---|\r\n");

            #line 54 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    foreach (var field in group.OrderBy(c => c.Name))
                    {
                        var isReadOnly = field.Modifiers.Any(c => string.Equals(c, "readonly", StringComparison.CurrentCultureIgnoreCase) ||
                                                             string.Equals(c, "const", StringComparison.CurrentCultureIgnoreCase));


            #line default
            #line hidden

            #line 59 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                        this.Write(this.ToStringHelper.ToStringWithCulture(field.Name));

            #line default
            #line hidden
                        this.Write(" | ");

            #line 59 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                        this.Write(this.ToStringHelper.ToStringWithCulture(isReadOnly ? "Read-Only" : string.Empty));

            #line default
            #line hidden
                        this.Write(" |\r\n");

            #line 60 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    }
                }
            }

/****** Display type properties ******/
            var properties = DefinitionFormatter.GetProperties(definition);
            if (properties.Any())
            {
            #line default
            #line hidden
                this.Write("\r\n## **Properties**\r\n");

            #line 72 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"

                foreach (var group in properties)
                {
            #line default
            #line hidden
                    this.Write("### **");

            #line 76 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    this.Write(this.ToStringHelper.ToStringWithCulture(CurrentCulture.TextInfo.ToTitleCase(group.Key)));

            #line default
            #line hidden
                    this.Write("**\r\n| Name  | Access |\r\n|---|---|\r\n");

            #line 79 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    foreach (var property in group.OrderBy(c => c.Name))
                    {
            #line default
            #line hidden

            #line 82 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                        this.Write(this.ToStringHelper.ToStringWithCulture(property.Name));

            #line default
            #line hidden
                        this.Write(" | ");

            #line 82 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                        this.Write(this.ToStringHelper.ToStringWithCulture(DefinitionFormatter.GetPropertyAccess(property)));

            #line default
            #line hidden
                        this.Write(" |\r\n");

            #line 83 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    }
                }
            }

/****** Display type events ******/
            var events = DefinitionFormatter.GetEvents(definition);
            if (events.Any())
            {
            #line default
            #line hidden
                this.Write("\r\n## **Events**\r\n");

            #line 95 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"

                foreach (var group in events)
                {
            #line default
            #line hidden
                    this.Write("### **");

            #line 99 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    this.Write(this.ToStringHelper.ToStringWithCulture(CurrentCulture.TextInfo.ToTitleCase(group.Key)));

            #line default
            #line hidden
                    this.Write("**\r\n| Name  | Type |\r\n|---|---|\r\n");

            #line 102 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    foreach (var ev in group.OrderBy(c => c.Name))
                    {
            #line default
            #line hidden

            #line 105 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                        this.Write(this.ToStringHelper.ToStringWithCulture(ev.Name));

            #line default
            #line hidden
                        this.Write(" | ");

            #line 105 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                        this.Write(this.ToStringHelper.ToStringWithCulture(MarkdownHelper.EscapeString(ev.Type)));

            #line default
            #line hidden
                        this.Write(" |\r\n");

            #line 106 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    }
                }
            }

/****** Display type events ******/
            var methods = DefinitionFormatter.GetMethods(definition);
            if (methods.Any())
            {
            #line default
            #line hidden
                this.Write("\r\n## **Methods**\r\n");

            #line 118 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"

                foreach (var group in methods)
                {
            #line default
            #line hidden
                    this.Write("### **");

            #line 122 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    this.Write(this.ToStringHelper.ToStringWithCulture(CurrentCulture.TextInfo.ToTitleCase(group.Key)));

            #line default
            #line hidden
                    this.Write("**\r\n| Name  | Parameters | Return\r\n|---|---|---|\r\n");

            #line 125 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"

                    var orderedMethods = group.OrderBy(c => c.Identity.Name).ThenBy(c => c.Parameters.Count());
                    foreach (var method in orderedMethods)
                    {
                        var methodParameters = String.Join(", ", method.Parameters.Select(c => c.Type));


            #line default
            #line hidden

            #line 131 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                        this.Write(this.ToStringHelper.ToStringWithCulture(MarkdownHelper.EscapeString(DefinitionFormatter.GetNameWithParameters(method.Identity))));

            #line default
            #line hidden
                        this.Write(" | (");

            #line 131 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                        this.Write(this.ToStringHelper.ToStringWithCulture(MarkdownHelper.EscapeString(methodParameters)));

            #line default
            #line hidden
                        this.Write(") | ");

            #line 131 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                        this.Write(this.ToStringHelper.ToStringWithCulture(MarkdownHelper.EscapeString(method.ReturnType)));

            #line default
            #line hidden
                        this.Write(" |\r\n");

            #line 132 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    }
                }
            }

/****** Display type enum values ******/
            var values = DefinitionFormatter.GetEnumValues(definition);
            if (values.Any())
            {
            #line default
            #line hidden
                this.Write("\r\n## **Values**\r\n| Name  | Value |\r\n|---|---|\r\n");

            #line 146 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"

                foreach (var enumValue in values)
                {
            #line default
            #line hidden

            #line 150 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    this.Write(this.ToStringHelper.ToStringWithCulture(enumValue.Name));

            #line default
            #line hidden
                    this.Write(" | ");

            #line 150 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    this.Write(this.ToStringHelper.ToStringWithCulture(enumValue.Value.GetValueOrDefault(string.Empty)));

            #line default
            #line hidden
                    this.Write(" |\r\n");

            #line 151 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                }
            }

/****** Display delegate parameters ******/
            var parameters = DefinitionFormatter.GetParameters(definition);
            if (parameters.Any())
            {
            #line default
            #line hidden
                this.Write("\r\n## **Parameters**\r\n| Name  | Type | Modifier | Default |\r\n|---|---|---|---|\r\n");

            #line 164 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"

                foreach (var delegateParameters in parameters)
                {
            #line default
            #line hidden

            #line 168 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    this.Write(this.ToStringHelper.ToStringWithCulture(delegateParameters.Name));

            #line default
            #line hidden
                    this.Write(" | ");

            #line 168 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    this.Write(this.ToStringHelper.ToStringWithCulture(MarkdownHelper.EscapeString(delegateParameters.Type)));

            #line default
            #line hidden
                    this.Write(" | ");

            #line 168 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    this.Write(this.ToStringHelper.ToStringWithCulture(delegateParameters.Modifier.GetValueOrDefault(string.Empty)));

            #line default
            #line hidden
                    this.Write(" | ");

            #line 168 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                    this.Write(this.ToStringHelper.ToStringWithCulture(delegateParameters.DefaultValue.GetValueOrDefault(string.Empty)));

            #line default
            #line hidden
                    this.Write(" |\r\n");

            #line 169 "D:\Users\Takumi\Documents\Projects\Markify\src\src\Markify.Rendering.T4\Templates\TypeTemplate.tt"
                }
            }


            #line default
            #line hidden
            return(this.GenerationEnvironment.ToString());
        }
        public void GetEvents_ShouldReturnExactEventsCount_WhenTypeHasSome(int expected, TypeDefinition definition)
        {
            var actual = DefinitionFormatter.GetProperties(definition).Select(c => c.Count());

            Check.That(actual).IsOnlyMadeOf(expected);
        }
        public void GetEvents_ShouldNotReturnNullElement_WhenTypeHasSome(TypeDefinition definition)
        {
            var actual = DefinitionFormatter.GetEvents(definition).SelectMany(c => c);

            Check.That(actual).Not.Contains(new object[] { null });
        }
 public void GetEvents_ShouldReturnNoEvents_WhenTypeCannotHave(TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetEvents(definition)).IsEmpty();
 }
Пример #15
0
        public void GetReturnType_ShouldReturnDelegateReturnType_WhenDefinitionIsDelegate(TypeDefinition definition)
        {
            var actual = ((TypeDefinition.Delegate)definition).Item.ReturnType;

            Check.That(DefinitionFormatter.GetReturnType(definition)).IsEqualTo(Option.Some(actual));
        }
        public void GetMethods_ShouldNotReturnListWithNullElement(TypeDefinition definition)
        {
            var actual = DefinitionFormatter.GetMethods(definition).SelectMany(c => c);

            Check.That(actual).Not.Contains(new object[] { null });
        }
Пример #17
0
 public void GetReturnType_ShouldReturnNone_WhenDefinitionIsNotDelegate(TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetReturnType(definition)).IsEqualTo(Option.None <string>());
 }
        public void GetMethods_ShouldReturnExpectedMethodsCount(int expected, TypeDefinition definition)
        {
            var actual = DefinitionFormatter.GetMethods(definition).SelectMany(c => c);

            Check.That(actual).HasSize(expected);
        }
 public void GetNameWithParameters_ShouldReturnNameWithParameters_WhenHasParameters(string expected, TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetNameWithParameters(definition.Identity)).IsEqualTo(expected);
 }
 public void GetMethods_ShouldReturnEmptyList_WhenDefinitionIsNotValid(TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetMethods(definition)).IsEmpty();
 }
 public void GetFields_ShouldReturnFieldsByVisiblity_WhenTypeHasSome(int expected, TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetFields(definition)).HasSize(expected);
 }
 public void GetParameters_ShouldReturnExpectedParameterCount(int expected, TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetParameters(definition)).HasSize(expected);
 }
 public void GetFields_ShouldReturnNoFields_WhenTypeCannotHaveFields(TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetFields(definition)).IsEmpty();
 }
 public void GetParameters_ShouldReturnEmptySequence_WhenDefinitionIsNotDelegate(TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetParameters(definition)).HasSize(0);
 }
 public void GetModifiers_ShouldReturnCorrectValue(string expected, TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetModifiers(definition)).IsEqualTo(expected);
 }
 public void GetKind_ShouldReturnCorrectKeyword(string expected, TypeDefinition definition)
 {
     Check.That(DefinitionFormatter.GetKind(definition)).IsEqualTo(expected);
 }
 public void GetPropertyAccess_ShouldReturnEmptyString_WhenAccesorArePrivate(PropertyDefinition definition)
 {
     Check.That(DefinitionFormatter.GetPropertyAccess(definition)).IsEmpty();
 }
Пример #28
0
 public void GetReturnType_ShouldThrowException_WhenDefinitionIsNull()
 {
     Check.ThatCode(() => DefinitionFormatter.GetReturnType(null)).Throws <ArgumentNullException>();
 }
 public void GetPropertyAccess_ShouldReturnReadAndWrite_WhenProprtyHasBothAccessor(PropertyDefinition definition)
 {
     Check.That(DefinitionFormatter.GetPropertyAccess(definition)).IsEqualTo("Read/Write");
 }
        public void GetTypeComment_ShouldReturnNone_WhenCommentDoesNotExist(TypeDefinition definition)
        {
            var actual = DefinitionFormatter.GetTypeComment(definition, c => c.Summary);

            Check.That(actual.IsSome()).IsFalse();
        }