9614734759

Committed 21 Jun 2024 01:50PM UTC coverage: 88.658% (+0.3%) from 88.335%

Build # 9614734759

Build Type

push

github

Committed by

JaCraig

Commit Message

fix: Fixing a couple of edge cases for generators

- Updated .editorconfig to refine C# coding style, including var usage, expression-bodied members, pattern matching, and more for better readability and performance.
- Adjusted namespaces in ClassGenerator.cs, ClassListGenerator.cs, and String.cs for better organization and to reflect feature categorization.
- Improved null safety and code robustness in ClassGenerator.cs and related files with null checks and default list initialization.
- Simplified string generation logic in String.cs and added null safety checks.
- Added new tests in ClassGeneratorTests.cs to validate class generation and property annotations.
- Made utility adjustments in test files to align with namespace changes and improve code clarity.

Run Details

558 of 856 branches covered (65.19%)

Branch coverage included in aggregate %.

12 of 14 new or added lines in 3 files covered. (85.71%)

12 existing lines in 5 files now uncovered.

3843 of 4108 relevant lines covered (93.55%)

93412.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.73

/src/Mirage/Generators/Default/ClassListGenerator.cs

﻿/*
Copyright 2017 James Craig

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

using BigBook;
using Mirage.Generators.BaseClasses;
using Mirage.Interfaces;
using Mirage.Manager;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;

namespace Mirage.Generators.Default
{
    /// <summary>
    /// Randomly generates a class that implements IList
    /// </summary>
    /// <typeparam name="T">Class type to generate</typeparam>
    /// <typeparam name="TListType">Type of the list.</typeparam>
    public class ClassListGenerator<T, TListType> : IGenerator<T>
    {
        /// <summary>
        /// Gets a value indicating whether this <see cref="IGenerator"/> is a default one.
        /// </summary>
        /// <value><c>true</c> if default; otherwise, <c>false</c>.</value>
        public bool Default => true;

        /// <summary>
        /// Gets the type generated.
        /// </summary>
        /// <value>The type generated.</value>
        public Type TypeGenerated => typeof(object);

        /// <summary>
        /// Generates a random version of the class
        /// </summary>
        /// <param name="rand">Random generator to use</param>
        /// <returns>The randomly generated class</returns>
        public T Next(Random rand) => (T?)NextObj(rand, new List<object>());

        /// <summary>
        /// Generates a random version of the class
        /// </summary>
        /// <param name="rand">Random generator to use</param>
        /// <param name="min">Min value (not used)</param>
        /// <param name="max">Max value (not used)</param>
        /// <returns>The randomly generated class</returns>
        public T Next(Random rand, T min, T max) => Activator.CreateInstance<T>();

        /// <summary>
        /// Gets a random version of the class
        /// </summary>
        /// <param name="rand">Random generator used</param>
        /// <param name="previouslySeen">The previously seen.</param>
        /// <returns>The randonly generated class</returns>
        public object? NextObj(Random rand, List<object> previouslySeen)
        {
            if (rand is null)
                return default;
            previouslySeen ??= new List<object>();
            var PreviousItem = previouslySeen.Find(x => x?.GetType() == typeof(T));
            if (PreviousItem != null)
                return PreviousItem;
            if (!typeof(T).HasDefaultConstructor())
                return default;
            T? ReturnItem = Activator.CreateInstance<T>();
            if (ReturnItem is null)
                return default;
            previouslySeen = previouslySeen.ToList();
            previouslySeen.Add(ReturnItem);
            Type ObjectType = typeof(T);
            foreach (PropertyInfo Property in ObjectType.GetProperties())
            {
                var Generated = false;
                ValidationAttribute[] ValidationAttributes = Property.Attributes<ValidationAttribute>();
                GeneratorAttributeBase? Attribute = Property.Attribute<GeneratorAttributeBase>();
                if (Attribute is not null)
                {
                    do
                    {
                        var TempValue = Attribute.NextObj(rand, previouslySeen);
                        if (ValidationAttributes.All(x => x.IsValid(TempValue)))
                        {
                            _ = ReturnItem.Property(Property, TempValue!);
                            Generated = true;
                        }
                    }
                    while (!Generated);
                }
            }
            var Count = rand.Next(0, 100);
            Type ClassType = typeof(TListType);
            var Results = rand.Next(ClassType, Count).Cast<TListType>().ToList();
            var ReturnItemList = (IList<TListType>)ReturnItem;
            for (var x = 0; x < Count; ++x)
            {
                ReturnItemList.Add(Results[x]);
            }
            return ReturnItem;
        }
    }

    /// <summary>
    /// Randomly generates a class that implements IList
    /// </summary>
    /// <seealso cref="GeneratorAttributeBase"/>
    public sealed class ClassListGeneratorAttribute : GeneratorAttributeBase
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ClassListGeneratorAttribute"/> class.
        /// </summary>
        /// <param name="classType">Type of the class.</param>
        public ClassListGeneratorAttribute(Type classType) : base(classType, classType)
        {
            ClassType = classType;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ClassListGeneratorAttribute"/> class.
        /// </summary>
        public ClassListGeneratorAttribute() : base(null, null)
        {
            ClassType = null;
        }

        /// <summary>
        /// Gets or sets the type of the class.
        /// </summary>
        /// <value>The type of the class.</value>
        public Type? ClassType { get; set; }

        /// <summary>
        /// Gets a value indicating whether this <see cref="T:Mirage.Interfaces.IGenerator"/> is a
        /// default one.
        /// </summary>
        /// <value><c>true</c> if default; otherwise, <c>false</c>.</value>
        public override bool Default => true;

        /// <summary>
        /// Gets the type generated.
        /// </summary>
        /// <value>The type generated.</value>
        public override Type TypeGenerated => typeof(object);

        /// <summary>
        /// Gets the method input types.
        /// </summary>
        /// <value>The method input types.</value>
        private Type[] MethodInputTypes { get; } = { typeof(Random), typeof(List<object>) };

        /// <summary>
        /// Generates next object
        /// </summary>
        /// <param name="rand">The rand.</param>
        /// <param name="previouslySeen">The previously seen.</param>
        /// <returns>The next object</returns>
        public override object? NextObj(Random rand, List<object> previouslySeen)
        {
            if (ClassType is null)
                return null;
            Type? IListType = ClassType.GetInterfaces().FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IList<>));
            if (IListType is null)
                return null;
            Type FinalClassType = typeof(ClassListGenerator<,>).MakeGenericType(ClassType, IListType.GetGenericArguments()[0]);
            MethodInfo? NextFunction = FinalClassType.GetTypeInfo().GetMethod(nameof(NextObj), MethodInputTypes);
            var Generator = Services.ServiceProvider?.GetService(FinalClassType);
            return NextFunction?.Invoke(Generator, new object[] { rand, previouslySeen });
        }
    }
}

1	/*
2	Copyright 2017 James Craig
3
4	Licensed under the Apache License, Version 2.0 (the "License");
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	http://www.apache.org/licenses/LICENSE-2.0
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16
17	using BigBook;
18	using Mirage.Generators.BaseClasses;
19	using Mirage.Interfaces;
20	using Mirage.Manager;
21	using System;
22	using System.Collections.Generic;
23	using System.ComponentModel.DataAnnotations;
24	using System.Linq;
25	using System.Reflection;
26
27	namespace Mirage.Generators.Default
28	{
29	/// <summary>
30	/// Randomly generates a class that implements IList
31	/// </summary>
32	/// <typeparam name="T">Class type to generate</typeparam>
33	/// <typeparam name="TListType">Type of the list.</typeparam>
34	public class ClassListGenerator<T, TListType> : IGenerator<T>
35	{
36	/// <summary>
37	/// Gets a value indicating whether this <see cref="IGenerator"/> is a default one.
38	/// </summary>
39	/// <value><c>true</c> if default; otherwise, <c>false</c>.</value>
40	public bool Default => true;	1✔
41
42	/// <summary>
43	/// Gets the type generated.
44	/// </summary>
45	/// <value>The type generated.</value>
46	public Type TypeGenerated => typeof(object);	1✔
47
48	/// <summary>
49	/// Generates a random version of the class
50	/// </summary>
51	/// <param name="rand">Random generator to use</param>
52	/// <returns>The randomly generated class</returns>
53	public T Next(Random rand) => (T?)NextObj(rand, new List<object>());	3✔
54
55	/// <summary>
56	/// Generates a random version of the class
57	/// </summary>
58	/// <param name="rand">Random generator to use</param>
59	/// <param name="min">Min value (not used)</param>
60	/// <param name="max">Max value (not used)</param>
61	/// <returns>The randomly generated class</returns>
62	public T Next(Random rand, T min, T max) => Activator.CreateInstance<T>();	11✔
63
64	/// <summary>
65	/// Gets a random version of the class
66	/// </summary>
67	/// <param name="rand">Random generator used</param>
68	/// <param name="previouslySeen">The previously seen.</param>
69	/// <returns>The randonly generated class</returns>
70	public object? NextObj(Random rand, List<object> previouslySeen)
71	{
72	if (rand is null)	33✔
73	return default;	8✔
74	previouslySeen ??= new List<object>();	25!
75	var PreviousItem = previouslySeen.Find(x => x?.GetType() == typeof(T));	145!
76	if (PreviousItem != null)	25!
77	return PreviousItem;	×
78	if (!typeof(T).HasDefaultConstructor())	25!
NEW 79	return default;	×
80	T? ReturnItem = Activator.CreateInstance<T>();	25✔
81	if (ReturnItem is null)	25!
82	return default;	×
83	previouslySeen = previouslySeen.ToList();	25✔
84	previouslySeen.Add(ReturnItem);	25✔
85	Type ObjectType = typeof(T);	25✔
86	foreach (PropertyInfo Property in ObjectType.GetProperties())	200✔
87	{
88	var Generated = false;	75✔
89	ValidationAttribute[] ValidationAttributes = Property.Attributes<ValidationAttribute>();	75✔
90	GeneratorAttributeBase? Attribute = Property.Attribute<GeneratorAttributeBase>();	75✔
91	if (Attribute is not null)	75!
92	{
93	do
94	{
95	var TempValue = Attribute.NextObj(rand, previouslySeen);	×
96	if (ValidationAttributes.All(x => x.IsValid(TempValue)))	×
97	{
98	_ = ReturnItem.Property(Property, TempValue!);	×
99	Generated = true;	×
100	}
101	}
102	while (!Generated);	×
103	}
104	}
105	var Count = rand.Next(0, 100);	25✔
106	Type ClassType = typeof(TListType);	25✔
107	var Results = rand.Next(ClassType, Count).Cast<TListType>().ToList();	25✔
108	var ReturnItemList = (IList<TListType>)ReturnItem;	25✔
109	for (var x = 0; x < Count; ++x)	2,998✔
110	{
111	ReturnItemList.Add(Results[x]);	1,474✔
112	}
113	return ReturnItem;	25✔
114	}
115	}
116
117	/// <summary>
118	/// Randomly generates a class that implements IList
119	/// </summary>
120	/// <seealso cref="GeneratorAttributeBase"/>
121	public sealed class ClassListGeneratorAttribute : GeneratorAttributeBase
122	{
123	/// <summary>
124	/// Initializes a new instance of the <see cref="ClassListGeneratorAttribute"/> class.
125	/// </summary>
126	/// <param name="classType">Type of the class.</param>
127	public ClassListGeneratorAttribute(Type classType) : base(classType, classType)	19✔
128	{
129	ClassType = classType;	19✔
130	}	19✔
131
132	/// <summary>
133	/// Initializes a new instance of the <see cref="ClassListGeneratorAttribute"/> class.
134	/// </summary>
135	public ClassListGeneratorAttribute() : base(null, null)	1✔
136	{
137	ClassType = null;	1✔
138	}	1✔
139
140	/// <summary>
141	/// Gets or sets the type of the class.
142	/// </summary>
143	/// <value>The type of the class.</value>
144	public Type? ClassType { get; set; }	77✔
145
146	/// <summary>
147	/// Gets a value indicating whether this <see cref="T:Mirage.Interfaces.IGenerator"/> is a
148	/// default one.
149	/// </summary>
150	/// <value><c>true</c> if default; otherwise, <c>false</c>.</value>
151	public override bool Default => true;	1✔
152
153	/// <summary>
154	/// Gets the type generated.
155	/// </summary>
156	/// <value>The type generated.</value>
157	public override Type TypeGenerated => typeof(object);	1✔
158
159	/// <summary>
160	/// Gets the method input types.
161	/// </summary>
162	/// <value>The method input types.</value>
163	private Type[] MethodInputTypes { get; } = { typeof(Random), typeof(List<object>) };	39✔
164
165	/// <summary>
166	/// Generates next object
167	/// </summary>
168	/// <param name="rand">The rand.</param>
169	/// <param name="previouslySeen">The previously seen.</param>
170	/// <returns>The next object</returns>
171	public override object? NextObj(Random rand, List<object> previouslySeen)
172	{
173	if (ClassType is null)	19!
174	return null;	×
175	Type? IListType = ClassType.GetInterfaces().FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IList<>));	38!
176	if (IListType is null)	19!
177	return null;	×
178	Type FinalClassType = typeof(ClassListGenerator<,>).MakeGenericType(ClassType, IListType.GetGenericArguments()[0]);	19✔
179	MethodInfo? NextFunction = FinalClassType.GetTypeInfo().GetMethod(nameof(NextObj), MethodInputTypes);	19✔
180	var Generator = Services.ServiceProvider?.GetService(FinalClassType);	19!
181	return NextFunction?.Invoke(Generator, new object[] { rand, previouslySeen });	19!
182	}
183	}
184	}

JaCraig / Mirage / 9614734759

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous