fix2

Author: DocSvartz

src/Mapster.Tests/WhenMappingMemberNameContainingPeriod.cs

@@ -19,7 +19,7 @@ public class WhenMappingMemberNameContainingPeriod
     public void Property_Name_Containing_Periods_Is_Supported()
     {
         // Create a target type with a property that contains periods
-        Type targetType = new TestTypeBuilder()
+        Type targetType = new TestTypeBuilder("Test1")
             .AddProperty<int>(MemberName)
             .CreateType();
 
@@ -53,12 +53,12 @@ static void Test<TTarget>()
     public void Constructor_Parameter_Name_Containing_Periods_Is_Supported()
     {
         // Create a target type with a property that contains periods
-        Type targetTypeWithProperty = new TestTypeBuilder()
+        Type targetTypeWithProperty = new TestTypeBuilder("Test2")
             .AddProperty<int>(MemberName)
             .CreateType();
 
         // Create a target type with a constructor parameter that contains periods
-        Type targetTypeWithConstructor = new TestTypeBuilder()
+        Type targetTypeWithConstructor = new TestTypeBuilder("Test3")
             .AddConstructorWithReadOnlyProperty<int>(MemberName)
             .CreateType();
 
@@ -103,7 +103,7 @@ static void Test<TWithProperty, TWithConstructor>()
     public void Using_Property_Path_String_Is_Supported()
     {
         // Create a target type with a property that contains periods
-        Type targetType = new TestTypeBuilder()
+        Type targetType = new TestTypeBuilder("Test4")
             .AddProperty<int>(MemberName)
             .CreateType();
 
@@ -129,7 +129,7 @@ public void Using_Property_Path_String_Is_Supported()
     public void Using_Property_Path_String_Nested_Is_Supported()
     {
         // Create a target type with a property that contains periods
-        Type targetType = new TestTypeBuilder()
+        Type targetType = new TestTypeBuilder("Test5")
             .AddProperty<Nested>(MemberName)
             .CreateType();
 
@@ -211,125 +211,125 @@ private class Nested
     private class Source
     {
         public int Value { get; set; }
-    }
-
-    private class TestTypeBuilder
-    {
-        private readonly TypeBuilder _typeBuilder;
-
-        public TestTypeBuilder()
-        {
-            AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(
-                new AssemblyName("Types"),
-                AssemblyBuilderAccess.Run);
-            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("<Module>");
-            _typeBuilder = moduleBuilder.DefineType(
-                "Types.Target",
-                TypeAttributes.Public |
-                TypeAttributes.Class |
-                TypeAttributes.Sealed |
-                TypeAttributes.AutoClass |
-                TypeAttributes.AnsiClass |
-                TypeAttributes.BeforeFieldInit |
-                TypeAttributes.AutoLayout,
-                null);
         }
 
-        public TestTypeBuilder AddConstructorWithReadOnlyProperty<TParameter>(string parameterName)
+        private class TestTypeBuilder
         {
-            // Add read-only property
-            FieldBuilder fieldBuilder = AddProperty<TParameter>(parameterName, false);
+            private readonly TypeBuilder _typeBuilder;
 
-            // Build the constructor with the parameter for the property
-            ConstructorBuilder constructorBuilder = _typeBuilder.DefineConstructor(
-                MethodAttributes.Public,
-                CallingConventions.Standard,
-                new Type[] { typeof(TParameter) });
+            public TestTypeBuilder(string TypeName)
+            {
+                AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(
+                    new AssemblyName("Types"),
+                    AssemblyBuilderAccess.Run);
+                ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("<Module>");
+                _typeBuilder = moduleBuilder.DefineType(
+                    $"Types.{TypeName}",
+                    TypeAttributes.Public |
+                    TypeAttributes.Class |
+                    TypeAttributes.Sealed |
+                    TypeAttributes.AutoClass |
+                    TypeAttributes.AnsiClass |
+                    TypeAttributes.BeforeFieldInit |
+                    TypeAttributes.AutoLayout,
+                    null);
+            }
 
-            // Define the parameter name
-            constructorBuilder.DefineParameter(1, ParameterAttributes.None, MemberName);
+            public TestTypeBuilder AddConstructorWithReadOnlyProperty<TParameter>(string parameterName)
+            {
+                // Add read-only property
+                FieldBuilder fieldBuilder = AddProperty<TParameter>(parameterName, false);
 
-            ILGenerator constructorIL = constructorBuilder.GetILGenerator();
+                // Build the constructor with the parameter for the property
+                ConstructorBuilder constructorBuilder = _typeBuilder.DefineConstructor(
+                    MethodAttributes.Public,
+                    CallingConventions.Standard,
+                    new Type[] { typeof(TParameter) });
 
-            // Call the base class constructor
-            constructorIL.Emit(OpCodes.Ldarg_0);
-            constructorIL.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
+                // Define the parameter name
+                constructorBuilder.DefineParameter(1, ParameterAttributes.None, MemberName);
 
-            // Set the property value
-            constructorIL.Emit(OpCodes.Ldarg_0);
-            constructorIL.Emit(OpCodes.Ldarg_1);
-            constructorIL.Emit(OpCodes.Stfld, fieldBuilder);
+                ILGenerator constructorIL = constructorBuilder.GetILGenerator();
 
-            constructorIL.Emit(OpCodes.Ret);
+                // Call the base class constructor
+                constructorIL.Emit(OpCodes.Ldarg_0);
+                constructorIL.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
 
-            return this;
-        }
+                // Set the property value
+                constructorIL.Emit(OpCodes.Ldarg_0);
+                constructorIL.Emit(OpCodes.Ldarg_1);
+                constructorIL.Emit(OpCodes.Stfld, fieldBuilder);
 
-        public TestTypeBuilder AddProperty<T>(string propertyName)
-        {
-            AddProperty<T>(propertyName, true);
-            return this;
-        }
+                constructorIL.Emit(OpCodes.Ret);
 
-        private FieldBuilder AddProperty<T>(string propertyName, bool addSetter)
-        {
-            Type propertyType = typeof(T);
-            FieldBuilder fieldBuilder = _typeBuilder.DefineField($"_{propertyName}", propertyType, FieldAttributes.Private);
-            PropertyBuilder propertyBuilder = _typeBuilder.DefineProperty(propertyName, PropertyAttributes.None, propertyType, null);
+                return this;
+            }
 
-            AddGetMethod(_typeBuilder, propertyBuilder, fieldBuilder, propertyName, propertyType);
-            if (addSetter)
+            public TestTypeBuilder AddProperty<T>(string propertyName)
             {
-                AddSetMethod(_typeBuilder, propertyBuilder, fieldBuilder, propertyName, propertyType);
+                AddProperty<T>(propertyName, true);
+                return this;
             }
 
-            return fieldBuilder;
-        }
+            private FieldBuilder AddProperty<T>(string propertyName, bool addSetter)
+            {
+                Type propertyType = typeof(T);
+                FieldBuilder fieldBuilder = _typeBuilder.DefineField($"_{propertyName}", propertyType, FieldAttributes.Private);
+                PropertyBuilder propertyBuilder = _typeBuilder.DefineProperty(propertyName, PropertyAttributes.None, propertyType, null);
 
-        public Type CreateType() => _typeBuilder.CreateType();
+                AddGetMethod(_typeBuilder, propertyBuilder, fieldBuilder, propertyName, propertyType);
+                if (addSetter)
+                {
+                    AddSetMethod(_typeBuilder, propertyBuilder, fieldBuilder, propertyName, propertyType);
+                }
 
-        private static PropertyBuilder AddGetMethod(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, FieldBuilder fieldBuilder, string propertyName, Type propertyType)
-        {
-            MethodBuilder getMethodBuilder = typeBuilder.DefineMethod(
-                "get_" + propertyName,
-                MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
-                propertyType,
-                Type.EmptyTypes);
-            ILGenerator getMethodGenerator = getMethodBuilder.GetILGenerator();
+                return fieldBuilder;
+            }
 
-            getMethodGenerator.Emit(OpCodes.Ldarg_0);
-            getMethodGenerator.Emit(OpCodes.Ldfld, fieldBuilder);
-            getMethodGenerator.Emit(OpCodes.Ret);
+            public Type CreateType() => _typeBuilder.CreateType();
 
-            propertyBuilder.SetGetMethod(getMethodBuilder);
+            private static PropertyBuilder AddGetMethod(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, FieldBuilder fieldBuilder, string propertyName, Type propertyType)
+            {
+                MethodBuilder getMethodBuilder = typeBuilder.DefineMethod(
+                    "get_" + propertyName,
+                    MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
+                    propertyType,
+                    Type.EmptyTypes);
+                ILGenerator getMethodGenerator = getMethodBuilder.GetILGenerator();
 
-            return propertyBuilder;
-        }
+                getMethodGenerator.Emit(OpCodes.Ldarg_0);
+                getMethodGenerator.Emit(OpCodes.Ldfld, fieldBuilder);
+                getMethodGenerator.Emit(OpCodes.Ret);
 
-        private static PropertyBuilder AddSetMethod(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, FieldBuilder fieldBuilder, string propertyName, Type propertyType)
-        {
-            MethodBuilder setMethodBuilder = typeBuilder.DefineMethod(
-                $"set_{propertyName}",
-                MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
-                null,
-                new Type[] { propertyType });
+                propertyBuilder.SetGetMethod(getMethodBuilder);
+
+                return propertyBuilder;
+            }
 
-            ILGenerator setMethodGenerator = setMethodBuilder.GetILGenerator();
-            Label modifyProperty = setMethodGenerator.DefineLabel();
-            Label exitSet = setMethodGenerator.DefineLabel();
+            private static PropertyBuilder AddSetMethod(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, FieldBuilder fieldBuilder, string propertyName, Type propertyType)
+            {
+                MethodBuilder setMethodBuilder = typeBuilder.DefineMethod(
+                    $"set_{propertyName}",
+                    MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
+                    null,
+                    new Type[] { propertyType });
+
+                ILGenerator setMethodGenerator = setMethodBuilder.GetILGenerator();
+                Label modifyProperty = setMethodGenerator.DefineLabel();
+                Label exitSet = setMethodGenerator.DefineLabel();
 
-            setMethodGenerator.MarkLabel(modifyProperty);
-            setMethodGenerator.Emit(OpCodes.Ldarg_0);
-            setMethodGenerator.Emit(OpCodes.Ldarg_1);
-            setMethodGenerator.Emit(OpCodes.Stfld, fieldBuilder);
+                setMethodGenerator.MarkLabel(modifyProperty);
+                setMethodGenerator.Emit(OpCodes.Ldarg_0);
+                setMethodGenerator.Emit(OpCodes.Ldarg_1);
+                setMethodGenerator.Emit(OpCodes.Stfld, fieldBuilder);
 
-            setMethodGenerator.Emit(OpCodes.Nop);
-            setMethodGenerator.MarkLabel(exitSet);
-            setMethodGenerator.Emit(OpCodes.Ret);
+                setMethodGenerator.Emit(OpCodes.Nop);
+                setMethodGenerator.MarkLabel(exitSet);
+                setMethodGenerator.Emit(OpCodes.Ret);
 
-            propertyBuilder.SetSetMethod(setMethodBuilder);
+                propertyBuilder.SetSetMethod(setMethodBuilder);
 
-            return propertyBuilder;
+                return propertyBuilder;
+            }
         }
     }
-}